dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Gimp/plug-ins/screenshot/screenshot-win32.c
Alx Sa 7e63e661f0 plug-ins: Show correct cursor in Windows Screenshot 
Resolves #14966
When "Include mouse pointer" is checked in the Windows
version of the Create Screenshot plug-in, we used the
GetCursor () Win32 API to get the cursor icon. However,
this just returns a generic cursor rather than the current one
used.
This patch changes the code to use the hCursor property of
the CursorInfo struct that was already retrieved, which contains
the current cursor's icon instead of the generic one.
2026-03-05 15:54:34 +00:00

1312 lines
35 KiB
C
Raw Permalink Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Screenshot plug-in
* Copyright 1998-2007 Sven Neumann <sven@gimp.org>
* Copyright 2003 Henrik Brix Andersen <brix@gimp.org>
* Copyright 2012 Simone Karin Lehmann - OS X patches
* Copyright 2018 Gil Eliyahu <gileli121@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <glib.h>
#ifdef G_OS_WIN32
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "screenshot.h"
#include "screenshot-win32.h"
#include "screenshot-win32-resource.h"
#include "libgimp/stdplugins-intl.h"
#include "screenshot-win32-magnification-api.h"
#include "screenshot-win32-dwm-api.h"
/*
* Application definitions
*/
#define SELECT_FRAME 0
#define SELECT_CLIENT 1
#define SELECT_WINDOW 2
#define SHOW_WINDOW FALSE
#define APP_NAME "plug_in_screenshot_win"
#define WM_DOCAPTURE (WM_USER + 100)
/* Prototypes */
void setCaptureType (int capType);
BOOL InitApplication (HINSTANCE hInstance);
BOOL InitInstance (HINSTANCE hInstance,
int nCmdShow);
int winsnapWinMain (void);
/* File variables */
static int captureType;
static char buffer[512];
static guchar *capBytes = NULL;
static HWND mainHwnd = NULL;
static HINSTANCE hInst = NULL;
static HCURSOR selectCursor = 0;
static ICONINFO iconInfo;
static MAGIMAGEHEADER returnedSrcheader;
static int rectScreensCount = 0;
static GimpImage **image;
static gboolean capturePointer = FALSE;
static void sendBMPToGimp (HBITMAP hBMP,
HDC hDC,
RECT rect);
static int doWindowCapture (void);
static gboolean doCapture (HWND selectedHwnd);
static BOOL isWindowIsAboveCaptureRegion (HWND hwndWindow,
RECT rectCapture);
static gboolean doCaptureMagnificationAPI (HWND selectedHwnd,
RECT rect);
static void doCaptureMagnificationAPI_callback (HWND hwnd,
void *srcdata,
MAGIMAGEHEADER srcheader,
void *destdata,
MAGIMAGEHEADER destheader,
RECT unclipped,
RECT clipped,
HRGN dirty);
static gboolean doCaptureBitBlt (HWND selectedHwnd,
RECT rect);
BOOL CALLBACK dialogProc (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
gboolean isDwmCompositionEnabled (void);
/* Data structure holding data between runs */
typedef struct {
gint root;
guint delay;
gint decor;
} WinSnapValues;
/* Default WinSnap values */
static WinSnapValues winsnapvals =
{
FALSE,
0,
TRUE,
};
/* The dialog information */
typedef struct {
#ifdef CAN_SET_DECOR
GtkWidget *decor_button;
#endif
GtkWidget *single_button;
GtkWidget *root_button;
GtkWidget *delay_spinner;
} WinSnapInterface;
/* We create a DIB section to hold the grabbed area. The scanlines in
* DIB sections are aligned on a LONG (four byte) boundary. Its pixel
* data is in RGB (BGR actually) format, three bytes per pixel.
*
* GIMP uses no alignment for its pixel regions. The GIMP image we
* create is of type RGB, i.e. three bytes per pixel, too. Thus in
* order to be able to quickly transfer all of the image at a time, we
* must use a DIB section and pixel region the scanline width in
* bytes of which is evenly divisible with both 3 and 4. I.e. it must
* be a multiple of 12 bytes, or in pixels, a multiple of four pixels.
*/
#define ROUND4(width) (((width-1)/4+1)*4)
gboolean
screenshot_win32_available (void)
{
return TRUE;
}
ScreenshotCapabilities
screenshot_win32_get_capabilities (void)
{
return (SCREENSHOT_CAN_SHOOT_DECORATIONS |
SCREENSHOT_CAN_SHOOT_WINDOW |
SCREENSHOT_CAN_SHOOT_POINTER |
SCREENSHOT_CAN_DELAY_WINDOW_SHOT);
}
GimpPDBStatusType
screenshot_win32_shoot (ShootType shoot_type,
guint screenshot_delay,
gboolean show_cursor,
GdkMonitor *monitor,
GimpImage **_image,
GError **error)
{
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
/* leave "monitor" alone until somebody patches the code
* to be able to get a monitor's color profile
*/
image = _image;
winsnapvals.delay = screenshot_delay;
capturePointer = show_cursor;
if (shoot_type == SHOOT_ROOT)
{
doCapture (0);
status = GIMP_PDB_SUCCESS;
}
else if (shoot_type == SHOOT_WINDOW)
{
status = 0 == doWindowCapture () ? GIMP_PDB_CANCEL : GIMP_PDB_SUCCESS;
}
else if (shoot_type == SHOOT_REGION)
{
/* FIXME */
}
if (status == GIMP_PDB_SUCCESS)
{
GimpColorProfile *profile;
/* XXX No idea if the "monitor" value is right at all, especially
* considering above comment. Just make so that it at least
* compiles!
*/
profile = gimp_monitor_get_color_profile (monitor);
if (profile)
{
gimp_image_set_color_profile (*image, profile);
g_object_unref (profile);
}
}
return status;
}
/******************************************************************
* GIMP format and transfer functions
******************************************************************/
/*
* flipRedAndBlueBytes
*
* Microsoft has chosen to provide us a very nice (not!)
* interface for retrieving bitmap bits. DIBSections have
* RGB information as BGR instead. So, we have to swap
* the silly red and blue bytes before sending to the
* GIMP.
*/
static void
flipRedAndBlueBytes (int width,
int height)
{
int i, j;
guchar *bufp;
guchar temp;
j = 0;
while (j < height) {
i = width;
bufp = capBytes + j*ROUND4(width)*3;
while (i--) {
temp = bufp[2];
bufp[2] = bufp[0];
bufp[0] = temp;
bufp += 3;
}
j++;
}
}
/*
* rgbaToRgbBytes
*
* Convert rgba array to rgb array
*/
static void
rgbaToRgbBytes (guchar *rgbBufp,
guchar *rgbaBufp,
int rgbaBufSize)
{
int rgbPoint = 0, rgbaPoint;
for (rgbaPoint = 0; rgbaPoint < rgbaBufSize; rgbaPoint += 4)
{
rgbBufp[rgbPoint++] = rgbaBufp[rgbaPoint];
rgbBufp[rgbPoint++] = rgbaBufp[rgbaPoint + 1];
rgbBufp[rgbPoint++] = rgbaBufp[rgbaPoint + 2];
}
}
/*
* sendBMPToGIMP
*
* Take the captured data and send it across
* to GIMP.
*/
static void
sendBMPToGimp (HBITMAP hBMP,
HDC hDC,
RECT rect)
{
int width, height;
int imageType, layerType;
GimpImage *new_image;
GimpLayer *layer;
GeglBuffer *buffer;
GeglRectangle *rectangle;
/* Our width and height */
width = (rect.right - rect.left);
height = (rect.bottom - rect.top);
/* Check that we got the memory */
if (!capBytes)
{
g_message (_("No data captured"));
return;
}
/* Flip the red and blue bytes */
flipRedAndBlueBytes (width, height);
/* Set up the image and layer types */
imageType = GIMP_RGB;
layerType = GIMP_RGB_IMAGE;
/* Create the GIMP image and layers */
new_image = gimp_image_new (width, height, imageType);
layer = gimp_layer_new (new_image, _("Background"),
ROUND4 (width), height,
layerType,
100,
gimp_image_get_default_new_layer_mode (new_image));
gimp_image_insert_layer (new_image, layer, NULL, 0);
/* make rectangle */
rectangle = g_new (GeglRectangle, 1);
rectangle->x = 0;
rectangle->y = 0;
rectangle->width = ROUND4(width);
rectangle->height = height;
/* get the buffer */
buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer));
/* fill the buffer */
gegl_buffer_set (buffer, rectangle, 0, NULL, (guchar *) capBytes,
GEGL_AUTO_ROWSTRIDE);
/* flushing data */
gegl_buffer_flush (buffer);
/* Now resize the layer down to the correct size if necessary. */
if (width != ROUND4 (width))
{
gimp_layer_resize (layer, width, height, 0, 0);
gimp_image_resize (new_image, width, height, 0, 0);
}
*image = new_image;
return;
}
/*
* doNonRootWindowCapture
*
* Capture a selected window.
* ENTRY POINT FOR WINSNAP NONROOT
*
*/
static int
doWindowCapture (void)
{
/* Start up a standard Win32
* message handling loop for
* selection of the window
* to be captured
*/
return winsnapWinMain ();
}
/******************************************************************
* Debug stuff
******************************************************************/
/*
* formatWindowsError
*
* Format the latest Windows error message into
* a readable string. Store in the provided
* buffer.
*/
static void
formatWindowsError (char *buffer,
int buf_size)
{
LPVOID lpMsgBuf;
/* Format the message */
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf, 0, NULL );
/* Copy to the buffer */
g_strlcpy (buffer, lpMsgBuf, buf_size);
LocalFree(lpMsgBuf);
}
/******************************************************************
* Bitmap capture and handling
******************************************************************/
/*
* primDoWindowCapture
*
* The primitive window capture functionality. Accepts
* the two device contexts and the rectangle to be
* captured.
*/
static HBITMAP
primDoWindowCapture (HDC hdcWindow,
HDC hdcCompat,
RECT rect)
{
HBITMAP hbmCopy;
HGDIOBJ oldObject;
BITMAPINFO bmi;
int width = (rect.right - rect.left);
int height = (rect.bottom - rect.top);
/* Create the bitmap info header */
bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = ROUND4(width);
bmi.bmiHeader.biHeight = -height;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 24;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biSizeImage = 0;
bmi.bmiHeader.biXPelsPerMeter =
bmi.bmiHeader.biYPelsPerMeter = 0;
bmi.bmiHeader.biClrUsed = 0;
bmi.bmiHeader.biClrImportant = 0;
/* Create the bitmap storage space */
hbmCopy = CreateDIBSection (hdcCompat,
(BITMAPINFO *) &bmi,
DIB_RGB_COLORS,
(void **)&capBytes, NULL, 0);
if (!hbmCopy)
{
formatWindowsError(buffer, sizeof buffer);
g_error("Error creating DIB section: %s", buffer);
return NULL;
}
/* Select the bitmap into the compatible DC. */
oldObject = SelectObject (hdcCompat, hbmCopy);
if (!oldObject)
{
formatWindowsError (buffer, sizeof buffer);
g_error ("Error selecting object: %s", buffer);
return NULL;
}
/* Copy the data from the application to the bitmap. Even if we did
* round up the width, BitBlt only the actual data.
*/
if (!BitBlt(hdcCompat, 0,0,
width, height,
hdcWindow, rect.left, rect.top,
SRCCOPY))
{
formatWindowsError (buffer, sizeof buffer);
g_error ("Error copying bitmap: %s", buffer);
return NULL;
}
/* Draw mouse pointer over screenshot if option was selected */
if (capturePointer)
{
CURSORINFO pointer = { sizeof (pointer) };
GetCursorInfo (&pointer);
DrawIcon (hdcCompat, pointer.ptScreenPos.x, pointer.ptScreenPos.y, pointer.hCursor);
}
/* Restore the original object */
SelectObject (hdcCompat, oldObject);
return hbmCopy;
}
static BOOL CALLBACK
GetAccurateWindowRect_MonitorEnumProc (HMONITOR hMonitor,
HDC hdcMonitor,
LPRECT lprcMonitor,
LPARAM dwData)
{
RECT **rectScreens = (RECT**) dwData;
if (!lprcMonitor) return FALSE;
if (! (*rectScreens))
*rectScreens = (RECT*) g_malloc (sizeof (RECT)*(rectScreensCount+1));
else
*rectScreens = (RECT*) g_realloc (*rectScreens,
sizeof (RECT)*(rectScreensCount+1));
if (*rectScreens == NULL)
{
rectScreensCount = 0;
return FALSE;
}
(*rectScreens)[rectScreensCount] = *lprcMonitor;
rectScreensCount++;
return TRUE;
}
static BOOL
GetAccurateWindowRect (HWND hwndTarget,
RECT *outRect)
{
HRESULT dwmResult;
WINDOWPLACEMENT windowplacment;
ZeroMemory (outRect, sizeof (RECT));
/* First we try to get the rect using the dwm api. it will also avoid us from doing more ugly fixes when the window is maximized */
if (LoadRequiredDwmFunctions ())
{
dwmResult = DwmGetWindowAttribute (hwndTarget, DWMWA_EXTENDED_FRAME_BOUNDS, (PVOID) outRect, sizeof (RECT));
UnloadRequiredDwmFunctions ();
if (dwmResult == S_OK) return TRUE;
}
/* In this case, we did not got the rect from the dwm api so we try to get the rect with the normal function */
if (GetWindowRect (hwndTarget, outRect))
{
/* If the window is maximized then we need and can fix the rect variable
* (we need to do this if the rect isn't coming from dwm api)
*/
ZeroMemory (&windowplacment, sizeof (WINDOWPLACEMENT));
if (GetWindowPlacement (hwndTarget, &windowplacment) && windowplacment.showCmd == SW_SHOWMAXIMIZED)
{
RECT *rectScreens = NULL;
int xCenter;
int yCenter;
int i;
/* If this is not the first time we call this function for some
* reason then we reset the rectScreens count
*/
if (rectScreensCount)
rectScreensCount = 0;
/* Get the screens rects */
EnumDisplayMonitors (NULL, NULL, GetAccurateWindowRect_MonitorEnumProc,
(LPARAM) &rectScreens);
/* If for some reason the array size is 0 then we fill it with the desktop rect */
if (! rectScreensCount)
{
rectScreens = (RECT*) g_malloc (sizeof (RECT));
if (! GetWindowRect (GetDesktopWindow (), rectScreens))
{
/* error: could not get rect screens */
g_free (rectScreens);
return FALSE;
}
rectScreensCount = 1;
}
xCenter = outRect->left + (outRect->right - outRect->left) / 2;
yCenter = outRect->top + (outRect->bottom - outRect->top) / 2;
/* find on which screen the window exist */
for (i = 0; i < rectScreensCount; i++)
if (xCenter > rectScreens[i].left && xCenter < rectScreens[i].right &&
yCenter > rectScreens[i].top && yCenter < rectScreens[i].bottom)
break;
if (i == rectScreensCount)
/* Error: did not found on which screen the window exist */
return FALSE;
if (rectScreens[i].left > outRect->left) outRect->left = rectScreens[i].left;
if (rectScreens[i].right < outRect->right) outRect->right = rectScreens[i].right;
if (rectScreens[i].top > outRect->top) outRect->top = rectScreens[i].top;
if (rectScreens[i].bottom < outRect->bottom) outRect->bottom = rectScreens[i].bottom;
g_free (rectScreens);
}
return TRUE;
}
return FALSE;
}
gboolean isDwmCompositionEnabled (void)
{
HRESULT err;
BOOL result;
if (LoadRequiredDwmFunctions ())
{
err = DwmIsCompositionEnabled (&result);
if (err != S_OK)
{
return FALSE;
}
return result;
}
return FALSE;
}
/*
* doCapture
*
* Do the capture. Accepts the window
* handle to be captured or the NULL value
* to specify the root window.
*/
static gboolean
doCapture (HWND selectedHwnd)
{
RECT rect;
/* Try and get everything out of the way before the
* capture.
*/
Sleep (500 + winsnapvals.delay * 1000);
/* Are we capturing a window or the whole screen */
if (selectedHwnd)
{
gboolean compositionEnabled;
if (! GetAccurateWindowRect (selectedHwnd, &rect))
/* For some reason it works only if we return here TRUE. strange... */
return TRUE;
/* First try to capture the window with the magnification api.
* This will solve the bug https://bugzilla.gnome.org/show_bug.cgi?id=793722/
*/
compositionEnabled = isDwmCompositionEnabled ();
if (! (compositionEnabled && doCaptureMagnificationAPI (selectedHwnd, rect)))
{
/* If for some reason this capture method failed then
* capture the window with the normal method:
*/
HWND previousHwnd = GetForegroundWindow ();
gboolean success;
SetForegroundWindow (selectedHwnd);
BringWindowToTop (selectedHwnd);
success = doCaptureBitBlt (selectedHwnd, rect);
if (previousHwnd)
SetForegroundWindow (previousHwnd);
return success;
}
return TRUE;
}
else
{
/* Get the screen's rectangle */
rect.top = GetSystemMetrics (SM_YVIRTUALSCREEN);
rect.bottom = GetSystemMetrics (SM_YVIRTUALSCREEN) + GetSystemMetrics (SM_CYVIRTUALSCREEN);
rect.left = GetSystemMetrics (SM_XVIRTUALSCREEN);
rect.right = GetSystemMetrics (SM_XVIRTUALSCREEN) + GetSystemMetrics (SM_CXVIRTUALSCREEN);
return doCaptureBitBlt (selectedHwnd, rect);
}
return FALSE; /* we should never get here... */
}
static gboolean
doCaptureBitBlt (HWND selectedHwnd,
RECT rect)
{
HDC hdcSrc;
HDC hdcCompat;
HBITMAP hbm;
/* Get the device context for the whole screen
* even if we just want to capture a window.
* this will allow to capture applications that
* don't render to their main window's device
* context (e.g. browsers).
*/
hdcSrc = CreateDC (TEXT("DISPLAY"), NULL, NULL, NULL);
if (!hdcSrc)
{
formatWindowsError(buffer, sizeof buffer);
g_error ("Error getting device context: %s", buffer);
return FALSE;
}
hdcCompat = CreateCompatibleDC (hdcSrc);
if (!hdcCompat)
{
formatWindowsError (buffer, sizeof buffer);
g_error ("Error getting compat device context: %s", buffer);
return FALSE;
}
/* Do the window capture */
hbm = primDoWindowCapture (hdcSrc, hdcCompat, rect);
if (!hbm)
return FALSE;
/* Release the device context */
ReleaseDC(selectedHwnd, hdcSrc);
if (hbm == NULL) return FALSE;
sendBMPToGimp (hbm, hdcCompat, rect);
return TRUE;
}
static void
doCaptureMagnificationAPI_callback (HWND hwnd,
void *srcdata,
MAGIMAGEHEADER srcheader,
void *destdata,
MAGIMAGEHEADER destheader,
RECT unclipped,
RECT clipped,
HRGN dirty)
{
if (!srcdata) return;
capBytes = (guchar*) malloc (sizeof (guchar)*srcheader.cbSize);
rgbaToRgbBytes (capBytes, srcdata, srcheader.cbSize);
returnedSrcheader = srcheader;
}
static BOOL
isWindowIsAboveCaptureRegion (HWND hwndWindow,
RECT rectCapture)
{
RECT rectWindow;
ZeroMemory (&rectWindow, sizeof (RECT));
if (!GetWindowRect (hwndWindow, &rectWindow)) return FALSE;
if (
(
(rectWindow.left >= rectCapture.left && rectWindow.left < rectCapture.right)
||
(rectWindow.right <= rectCapture.right && rectWindow.right > rectCapture.left)
||
(rectWindow.left <= rectCapture.left && rectWindow.right >= rectCapture.right)
)
&&
(
(rectWindow.top >= rectCapture.top && rectWindow.top < rectCapture.bottom)
||
(rectWindow.bottom <= rectCapture.bottom && rectWindow.bottom > rectCapture.top)
||
(rectWindow.top <= rectCapture.top && rectWindow.bottom >= rectCapture.bottom)
)
)
return TRUE;
else
return FALSE;
}
static gboolean
doCaptureMagnificationAPI (HWND selectedHwnd,
RECT rect)
{
HWND hwndMag;
HWND hwndHost;
HWND nextWindow;
HWND excludeWins[24];
RECT round4Rect;
int excludeWinsCount = 0;
int magStyles;
if (!LoadMagnificationLibrary ()) return FALSE;
if (!MagInitialize ()) return FALSE;
round4Rect = rect;
round4Rect.right = round4Rect.left + ROUND4(round4Rect.right - round4Rect.left);
/* Create the host window that will store the mag child window */
hwndHost = CreateWindowEx (0x08000000 | 0x080000 | 0x80 | 0x20, APP_NAME, NULL, 0x80000000,
0, 0, 0, 0, NULL, NULL, GetModuleHandleW (NULL), NULL);
if (!hwndHost)
{
MagUninitialize ();
return FALSE;
}
SetLayeredWindowAttributes (hwndHost, (COLORREF)0, (BYTE)255, (DWORD)0x02);
magStyles = WS_CHILD;
if (capturePointer)
magStyles |= MS_SHOWMAGNIFIEDCURSOR;
/* Create the mag child window inside the host window */
hwndMag = CreateWindow (WC_MAGNIFIER, TEXT ("MagnifierWindow"),
magStyles,
0, 0, round4Rect.right - round4Rect.left, round4Rect.bottom - round4Rect.top,
hwndHost, NULL, GetModuleHandleW (NULL), NULL);
/* Set the callback function that will be called by the api to get the pixels */
if (!MagSetImageScalingCallback (hwndMag, (MagImageScalingCallback)doCaptureMagnificationAPI_callback))
{
DestroyWindow (hwndHost);
MagUninitialize ();
return FALSE;
}
/* Add only windows that above the target window */
for (nextWindow = GetNextWindow (selectedHwnd, GW_HWNDPREV); nextWindow != NULL; nextWindow = GetNextWindow (nextWindow, GW_HWNDPREV))
if (isWindowIsAboveCaptureRegion (nextWindow, rect))
{
excludeWins[excludeWinsCount++] = nextWindow;
/* This api can't work with more than 24 windows. we stop on the 24 window */
if (excludeWinsCount >= 24) break;
}
if (excludeWinsCount)
MagSetWindowFilterList (hwndMag, MW_FILTERMODE_EXCLUDE, excludeWinsCount, excludeWins);
/* Call the api to capture the window */
capBytes = NULL;
if (!MagSetWindowSource (hwndMag, round4Rect) || !capBytes)
{
DestroyWindow (hwndHost);
MagUninitialize ();
return FALSE;
}
/* Send it to Gimp */
sendBMPToGimp (NULL, NULL, rect);
DestroyWindow (hwndHost);
MagUninitialize ();
return TRUE;
}
/******************************************************************
* Win32 entry point and setup...
******************************************************************/
#define DINV 3
/*
* highlightWindowFrame
*
* Highlight (or unhighlight) the specified
* window handle's frame.
*/
static void
highlightWindowFrame (HWND hWnd)
{
HDC hdc;
RECT rc;
if (!IsWindow (hWnd))
return;
hdc = GetWindowDC (hWnd);
GetWindowRect (hWnd, &rc);
OffsetRect (&rc, -rc.left, -rc.top);
if (!IsRectEmpty (&rc))
{
PatBlt (hdc, rc.left, rc.top, rc.right-rc.left, DINV, DSTINVERT);
PatBlt (hdc, rc.left, rc.bottom-DINV, DINV, -(rc.bottom-rc.top-2*DINV),
DSTINVERT);
PatBlt (hdc, rc.right-DINV, rc.top+DINV, DINV, rc.bottom-rc.top-2*DINV,
DSTINVERT);
PatBlt (hdc, rc.right, rc.bottom-DINV, -(rc.right-rc.left), DINV,
DSTINVERT);
}
ReleaseDC (hWnd, hdc);
UpdateWindow (hWnd);
}
/*
* setCaptureType
*
* Set the capture type. Should be one of:
* SELECT_FRAME
* SELECT_CLIENT
* SELECT_WINDOW
*/
void
setCaptureType (int capType)
{
captureType = capType;
}
/*
* myWindowFromPoint
*
* Map to the appropriate window from the
* specified point. The chosen window is
* based on the current capture type.
*/
static HWND
myWindowFromPoint (POINT pt)
{
HWND myHwnd;
HWND nextHwnd;
switch (captureType)
{
case SELECT_FRAME:
case SELECT_CLIENT:
nextHwnd = WindowFromPoint (pt);
do {
myHwnd = nextHwnd;
nextHwnd = GetParent (myHwnd);
} while (nextHwnd);
return myHwnd;
break;
case SELECT_WINDOW:
return WindowFromPoint (pt);
break;
}
return WindowFromPoint (pt);
}
/*
* dialogProc
*
* The window procedure for the window
* selection dialog box.
*/
BOOL CALLBACK
dialogProc (HWND hwndDlg,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
static int mouseCaptured;
static int buttonDown;
static HCURSOR oldCursor;
static RECT bitmapRect;
static HWND highlightedHwnd = NULL;
switch (msg)
{
case WM_INITDIALOG:
{
int nonclientHeight;
HWND hwndGroup;
RECT dlgRect;
RECT clientRect;
RECT groupRect;
BITMAP bm;
/* Set the mouse capture flag */
buttonDown = 0;
mouseCaptured = 0;
/* Calculate the bitmap dimensions */
GetObject (iconInfo.hbmMask, sizeof(BITMAP), (VOID *)&bm);
/* Calculate the dialog window dimensions */
GetWindowRect (hwndDlg, &dlgRect);
/* Calculate the group box dimensions */
hwndGroup = GetDlgItem(hwndDlg, IDC_GROUP);
GetWindowRect (hwndGroup, &groupRect);
OffsetRect (&groupRect, -dlgRect.left, -dlgRect.top);
/* The client's rectangle */
GetClientRect (hwndDlg, &clientRect);
/* The non-client height */
nonclientHeight = (dlgRect.bottom - dlgRect.top) -
(clientRect.bottom - clientRect.top);
/* Calculate the bitmap rectangle */
bitmapRect.top = ((groupRect.top + groupRect.bottom) / 2) -
(bm.bmHeight / 2);
bitmapRect.top -= nonclientHeight;
bitmapRect.bottom = bitmapRect.top + bm.bmHeight;
bitmapRect.left = ((groupRect.left + groupRect.right) / 2) - (bm.bmWidth / 2);
bitmapRect.right = bitmapRect.left + bm.bmWidth;
}
break;
case WM_LBUTTONDOWN:
/* Track the button down state */
buttonDown = 1;
break;
case WM_LBUTTONUP:
buttonDown = 0;
/* If we have mouse captured
* we do this stuff.
*/
if (mouseCaptured)
{
HWND selectedHwnd;
POINT cursorPos;
/* Release the capture */
mouseCaptured = 0;
SetCursor (oldCursor);
ReleaseCapture ();
/* Remove the highlight */
if (highlightedHwnd)
highlightWindowFrame (highlightedHwnd);
RedrawWindow (hwndDlg, NULL, NULL, RDW_INVALIDATE);
/* Return the selected window */
GetCursorPos (&cursorPos);
selectedHwnd = myWindowFromPoint (cursorPos);
EndDialog (hwndDlg, (INT_PTR) selectedHwnd);
}
break;
case WM_MOUSEMOVE:
/* If the mouse is captured, show
* the window which is tracking
* under the mouse position.
*/
if (mouseCaptured)
{
HWND currentHwnd;
POINT cursorPos;
/* Get the window */
GetCursorPos (&cursorPos);
currentHwnd = myWindowFromPoint (cursorPos);
/* Do the highlighting */
if (highlightedHwnd != currentHwnd)
{
if (highlightedHwnd)
highlightWindowFrame (highlightedHwnd);
if (currentHwnd)
highlightWindowFrame (currentHwnd);
highlightedHwnd = currentHwnd;
}
/* If the mouse has not been captured,
* try to figure out if we should capture
* the mouse.
*/
}
else if (buttonDown)
{
POINT cursorPos;
/* Get the current client position */
GetCursorPos (&cursorPos);
ScreenToClient (hwndDlg, &cursorPos);
/* Check if within the rectangle formed
* by the bitmap
*/
if (PtInRect (&bitmapRect, cursorPos)) {
mouseCaptured = 1;
oldCursor = SetCursor (selectCursor);
SetCapture (hwndDlg);
RedrawWindow (hwndDlg, NULL, NULL, RDW_INVALIDATE | RDW_ERASE);
}
}
break;
case WM_PAINT:
{
HDC hDC;
PAINTSTRUCT ps;
/* If the mouse is not captured draw
* the cursor image
*/
if (!mouseCaptured)
{
hDC = BeginPaint (hwndDlg, &ps);
DrawIconEx (hDC, bitmapRect.left, bitmapRect.top, selectCursor,
0, 0, 0, NULL, DI_NORMAL);
EndPaint (hwndDlg, &ps);
}
}
break;
case WM_COMMAND:
/* Handle the cancel button */
switch (LOWORD (wParam))
{
case IDCANCEL:
EndDialog (hwndDlg, 0);
return TRUE;
break;
}
}
return FALSE;
}
///* Don't use the normal WinMain from gimp.h */
//#define WinMain WinMain_no_thanks
//MAIN()
//#undef WinMain
/*
* WinMain
*
* The standard gimp plug-in WinMain won't quite cut it for
* this plug-in.
*/
//int APIENTRY
//WinMain(HINSTANCE hInstance,
// HINSTANCE hPrevInstance,
// LPSTR lpCmdLine,
// int nCmdShow)
//{
// /*
// * Normally, we would do all of the Windows-ish set up of
// * the window classes and stuff here in WinMain. But,
// * the only time we really need the window and message
// * queues is during the plug-in run. So, all of that will
// * be done during run(). This avoids all of the Windows
// * setup stuff for the query(). Stash the instance handle now
// * so it is available from the run() procedure.
// */
// hInst = hInstance;
//
// /*
// * Now, call gimp_main... This is what the normal WinMain()
// * would do.
// */
//// return gimp_main(&PLUG_IN_INFO, __argc, __argv);
//}
/*
* InitApplication
*
* Initialize window data and register the window class
*/
BOOL
InitApplication (HINSTANCE hInstance)
{
WNDCLASS wc;
BOOL retValue;
/* Get some resources */
#ifdef _MSC_VER
/* For some reason this works only with MSVC */
selectCursor = LoadCursor (hInstance, MAKEINTRESOURCE(IDC_SELECT));
#else
selectCursor = LoadCursor (NULL, IDC_CROSS);
#endif
GetIconInfo (selectCursor, &iconInfo);
/*
* Fill in window class structure with parameters to describe
* the main window.
*/
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC) WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor (NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
wc.lpszClassName = APP_NAME;
wc.lpszMenuName = NULL;
/* Register the window class and stash success/failure code. */
retValue = RegisterClass (&wc);
/* Log error */
if (!retValue)
{
formatWindowsError (buffer, sizeof buffer);
g_error ("Error registering class: %s", buffer);
return retValue;
}
return retValue;
}
/*
* InitInstance
*
* Create the main window for the application.
*/
BOOL
InitInstance (HINSTANCE hInstance,
int nCmdShow)
{
HINSTANCE User32Library = LoadLibraryW (L"user32.dll");
if (User32Library)
{
typedef BOOL (WINAPI* SET_PROC_DPI_AWARE)();
SET_PROC_DPI_AWARE SetProcessDPIAware;
/* This line fix bug: https://bugzilla.gnome.org/show_bug.cgi?id=796121#c4 */
SetProcessDPIAware = (SET_PROC_DPI_AWARE) GetProcAddress (User32Library,
"SetProcessDPIAware");
if (SetProcessDPIAware)
SetProcessDPIAware();
FreeLibrary (User32Library);
}
/* Create our window */
mainHwnd = CreateWindow (APP_NAME, APP_NAME, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
NULL, NULL, hInstance, NULL);
if (!mainHwnd)
{
return (FALSE);
}
ShowWindow (mainHwnd, nCmdShow);
UpdateWindow (mainHwnd);
return TRUE;
}
/*
* winsnapWinMain
*
* This is the function that represents the code that
* would normally reside in WinMain (see above). This
* function will get called during run() in order to set
* up the windowing environment necessary for WinSnap to
* operate.
*/
int
winsnapWinMain (void)
{
MSG msg;
/* Perform instance initialization */
if (!InitApplication (hInst))
return (FALSE);
/* Perform application initialization */
if (!InitInstance (hInst, SHOW_WINDOW))
return (FALSE);
/* Main message loop */
while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage (&msg);
DispatchMessage (&msg);
}
return (msg.wParam);
}
/*
* WndProc
*
* Process window message for the main window.
*/
LRESULT CALLBACK
WndProc (HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
HWND selectedHwnd;
switch (message)
{
case WM_CREATE:
/* The window is created... Send the capture message */
PostMessage (hwnd, WM_DOCAPTURE, 0, 0);
break;
case WM_DOCAPTURE:
/* Get the selected window handle */
selectedHwnd = (HWND) DialogBox (hInst, MAKEINTRESOURCE(IDD_SELECT),
hwnd, (DLGPROC) dialogProc);
if (selectedHwnd)
doCapture (selectedHwnd);
PostQuitMessage (selectedHwnd != NULL);
break;
case WM_DESTROY:
PostQuitMessage (0);
break;
default:
return (DefWindowProc (hwnd, message, wParam, lParam));
}
return 0;
}
#endif /* G_OS_WIN32 */
Reference in a new issue View git blame Copy permalink