diff options
Diffstat (limited to 'libgimpwidgets/gimppickbutton-win32.c')
| -rw-r--r-- | libgimpwidgets/gimppickbutton-win32.c | 1135 |
1 files changed, 1135 insertions, 0 deletions
diff --git a/libgimpwidgets/gimppickbutton-win32.c b/libgimpwidgets/gimppickbutton-win32.c new file mode 100644 index 0000000..d5ca8b7 --- /dev/null +++ b/libgimpwidgets/gimppickbutton-win32.c @@ -0,0 +1,1135 @@ +/* LIBGIMP - The GIMP Library + * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball + * + * gimppickbutton-win32.c + * Copyright (C) 2022 Luca Bacci <luca.bacci@outlook.com> + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gegl.h> +#include <gtk/gtk.h> + +#include "libgimpcolor/gimpcolor.h" + +#include "gimpwidgetstypes.h" +#include "gimppickbutton.h" +#include "gimppickbutton-win32.h" + +#include <sdkddkver.h> +#include <windows.h> +#include <windowsx.h> + +#include <stdint.h> + +/* + * NOTES: + * + * This implementation is based on gtk/gtkcolorpickerwin32.c from GTK. + * + * We install a low-level mouse hook so that color picking continues + * even when switching active windows. + * + * Beyond that, we also create keep-above, input-only HWNDs and place + * them on the screen to cover each monitor. This is done to show our + * custom cursor and to avoid giving input to other windows: that way + * the desktop appears "frozen" while picking the color. + * + * Finally, we also set up a low-level keyboard hook to dismiss color- + * picking mode whenever the user presses <ESC>. + * + * Note that low-level hooks for mouse and keyboard do not use any DLL + * injection and are thus non-invasive. + * + * For GTK4: consider using an appropriate GDK surface for input-only + * windows. This'd enable us to also get Wintab input when CXO_SYSTEM + * is not set. + */ + +typedef struct +{ + HMONITOR handle; + wchar_t *device; + HDC hdc; + POINT screen_origin; + int logical_width; + int logical_height; + int physical_width; + int physical_height; +} MonitorData; + +GList *pickers; +HHOOK mouse_hook; +HHOOK keyboard_hook; + +ATOM notif_window_class; +HWND notif_window_handle; +GArray *monitors; + +ATOM input_window_class; +GArray *input_window_handles; + +/* Utils */ +static HMODULE this_module (void); +static MonitorData * monitors_find_for_logical_point (POINT logical); +static MonitorData * monitors_find_for_physical_point (POINT physical); +static POINT logical_to_physical (MonitorData *data, + POINT logical); +static void destroy_window (gpointer ptr); + +/* Mouse cursor */ +static HCURSOR create_cursor_from_rgba32_pixbuf (GdkPixbuf *pixbuf, + POINT hotspot); +static HCURSOR create_cursor (void); + +/* Low-level mouse hook */ +static LRESULT CALLBACK mouse_procedure (int nCode, + WPARAM wParam, + LPARAM lParam); +static gboolean ensure_mouse_hook (void); +static void remove_mouse_hook (void); + +/* Low-level keyboard hook */ +static LRESULT CALLBACK keyboard_procedure (int nCode, + WPARAM wParam, + LPARAM lParam); +static gboolean ensure_keyboard_hook (void); +static void remove_keyboard_hook (void); + +/* Input-only window */ +static LRESULT CALLBACK input_window_procedure (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam); +static gboolean ensure_input_window_class (void); +static void remove_input_window_class (void); +static HWND create_input_window (POINT origin, + int width, + int height); + +/* Hidden notification window */ +static LRESULT CALLBACK notif_window_procedure (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam); +static gboolean ensure_notif_window_class (void); +static void remove_notif_window_class (void); +static gboolean ensure_notif_window (void); +static void remove_notif_window (void); + +/* Monitor enumeration and discovery */ +static void monitor_data_free (gpointer ptr); +static BOOL CALLBACK enum_monitor_callback (HMONITOR hMonitor, + HDC hDC, + RECT *pRect, + LPARAM lParam); +static GArray* enumerate_monitors (void); + +/* GimpPickButtonWin32 */ +static void ensure_input_windows (void); +static void remove_input_windows (void); +static void ensure_monitors (void); +static void remove_monitors (void); +static void ensure_screen_data (void); +static void remove_screen_data (void); +static void screen_changed (void); +static void ensure_screen_tracking (void); +static void remove_screen_tracking (void); +static GimpRGB pick_color_with_gdi (POINT physical_point); +static void user_picked (MonitorData *monitor, + POINT physical_point); +void _gimp_pick_button_win32_pick (GimpPickButton *button); +static void stop_picking (void); + +/* {{{ Utils */ + +/* Gets a handle to the module containing this code. + * Works regardless if we're building a shared or + * static library */ + +static HMODULE +this_module (void) +{ + extern IMAGE_DOS_HEADER __ImageBase; + return (HMODULE) &__ImageBase; +} + +static MonitorData* +monitors_find_for_logical_point (POINT logical) +{ + HMONITOR monitor_handle; + guint i; + + monitor_handle = MonitorFromPoint (logical, MONITOR_DEFAULTTONULL); + if (!monitor_handle) + return NULL; + + ensure_monitors (); + + for (i = 0; i < monitors->len; i++) + { + MonitorData *data = &g_array_index (monitors, MonitorData, i); + + if (data->handle == monitor_handle) + return data; + } + + return NULL; +} + +static MonitorData* +monitors_find_for_physical_point (POINT physical) +{ + guint i; + + ensure_monitors (); + + for (i = 0; i < monitors->len; i++) + { + MonitorData *data = &g_array_index (monitors, MonitorData, i); + RECT physical_rect; + + physical_rect.left = data->screen_origin.x; + physical_rect.top = data->screen_origin.y; + physical_rect.right = physical_rect.left + data->physical_width; + physical_rect.bottom = physical_rect.top + data->physical_height; + + /* TODO: tolerance */ + if (PtInRect (&physical_rect, physical)) + return data; + } + + return NULL; +} + +static POINT +logical_to_physical (MonitorData *data, + POINT logical) +{ + POINT physical = logical; + + if (data && + (data->logical_width != data->physical_width) && + data->logical_width > 0 && data->physical_width > 0) + { + double dpi_scale = (double) data->physical_width / + (double) data->logical_width; + + physical.x = logical.x * dpi_scale; + physical.y = logical.y * dpi_scale; + } + + return physical; +} + +static void +destroy_window (gpointer ptr) +{ + HWND *hwnd = (HWND*) ptr; + DestroyWindow (*hwnd); +} + +/* }}} + * {{{ Mouse cursor */ + +static HCURSOR +create_cursor_from_rgba32_pixbuf (GdkPixbuf *pixbuf, + POINT hotspot) +{ + struct { + BITMAPV5HEADER header; + RGBQUAD colors[2]; + } info; + HBITMAP bitmap = NULL; + uint8_t *bitmap_data = NULL; + HBITMAP mask = NULL; + uint8_t *mask_data = NULL; + unsigned int mask_stride; + HDC hdc = NULL; + int width; + int height; + int size; + int stride; + const uint8_t *pixbuf_data = NULL; + int i_offset; + int j_offset; + int i; + int j; + ICONINFO icon_info; + HICON icon = NULL; + + if (gdk_pixbuf_get_n_channels (pixbuf) != 4) + goto cleanup; + + hdc = GetDC (NULL); + if (!hdc) + goto cleanup; + + width = gdk_pixbuf_get_width (pixbuf); + height = gdk_pixbuf_get_height (pixbuf); + stride = gdk_pixbuf_get_rowstride (pixbuf); + size = MAX (width, height); + pixbuf_data = gdk_pixbuf_read_pixels (pixbuf); + + memset (&info, 0, sizeof (info)); + info.header.bV5Size = sizeof (info.header); + info.header.bV5Width = size; + info.header.bV5Height = size; + /* Since Windows XP the OS supports mouse cursors as 32bpp + * bitmaps with alpha channel that are laid out as BGRA32 + * (assuming little-endian) */ + info.header.bV5Planes = 1; + info.header.bV5BitCount = 32; + info.header.bV5Compression = BI_BITFIELDS; + info.header.bV5BlueMask = 0x000000FF; + info.header.bV5GreenMask = 0x0000FF00; + info.header.bV5RedMask = 0x00FF0000; + info.header.bV5AlphaMask = 0xFF000000; + + bitmap = CreateDIBSection (hdc, (BITMAPINFO*) &info, DIB_RGB_COLORS, + (void**) &bitmap_data, NULL, 0); + if (!bitmap || !bitmap_data) + { + g_warning ("CreateDIBSection failed with error code %u", + (unsigned) GetLastError ()); + goto cleanup; + } + + /* We also need to provide a proper mask HBITMAP, otherwise + * CreateIconIndirect() fails with ERROR_INVALID_PARAMETER. + * This mask bitmap is a bitfield indicating whether the */ + memset (&info, 0, sizeof (info)); + info.header.bV5Size = sizeof (info.header); + info.header.bV5Width = size; + info.header.bV5Height = size; + info.header.bV5Planes = 1; + info.header.bV5BitCount = 1; + info.header.bV5Compression = BI_RGB; + info.colors[0] = (RGBQUAD){0x00, 0x00, 0x00}; + info.colors[1] = (RGBQUAD){0xFF, 0xFF, 0xFF}; + + mask = CreateDIBSection (hdc, (BITMAPINFO*) &info, DIB_RGB_COLORS, + (void**) &mask_data, NULL, 0); + if (!mask || !mask_data) + { + g_warning ("CreateDIBSection failed with error code %u", + (unsigned) GetLastError ()); + goto cleanup; + } + + /* MSDN says mask rows are aligned to LONG boundaries */ + mask_stride = (((size + 31) & ~31) >> 3); + + if (width > height) + { + i_offset = 0; + j_offset = (width - height) / 2; + } + else + { + i_offset = (height - width) / 2; + j_offset = 0; + } + + for (j = 0; j < height; j++) /* loop over all the bitmap rows */ + { + uint8_t *bitmap_row = bitmap_data + 4 * ((j + j_offset) * size + i_offset); + uint8_t *mask_byte = mask_data + (j + j_offset) * mask_stride + i_offset / 8; + unsigned int mask_bit = (0x80 >> (i_offset % 8)); + const uint8_t *pixbuf_row = pixbuf_data + (height - j - 1) * stride; + + for (i = 0; i < width; i++) /* loop over the current bitmap row */ + { + uint8_t *bitmap_pixel = bitmap_row + 4 * i; + const uint8_t *pixbuf_pixel = pixbuf_row + 4 * i; + + /* Assign to destination pixel from source pixel + * by also swapping channels as appropriate */ + bitmap_pixel[0] = pixbuf_pixel[2]; + bitmap_pixel[1] = pixbuf_pixel[1]; + bitmap_pixel[2] = pixbuf_pixel[0]; + bitmap_pixel[3] = pixbuf_pixel[3]; + + if (pixbuf_pixel[3] == 0) + mask_byte[0] |= mask_bit; /* turn ON bit */ + else + mask_byte[0] &= ~mask_bit; /* turn OFF bit */ + + mask_bit >>= 1; + if (mask_bit == 0) + { + mask_bit = 0x80; + mask_byte++; + } + } + } + + memset (&icon_info, 0, sizeof (icon_info)); + icon_info.fIcon = FALSE; + icon_info.xHotspot = hotspot.x; + icon_info.yHotspot = hotspot.y; + icon_info.hbmMask = mask; + icon_info.hbmColor = bitmap; + + icon = CreateIconIndirect (&icon_info); + if (!icon) + { + g_warning ("CreateIconIndirect failed with error code %u", + (unsigned) GetLastError ()); + goto cleanup; + } + +cleanup: + if (mask) + DeleteObject (mask); + + if (bitmap) + DeleteObject (bitmap); + + if (hdc) + ReleaseDC (NULL, hdc); + + return (HCURSOR) icon; +} + +static HCURSOR +create_cursor (void) +{ + GdkPixbuf *pixbuf = NULL; + GError *error = NULL; + HCURSOR cursor = NULL; + + pixbuf = gdk_pixbuf_new_from_resource ("/org/gimp/color-picker-cursors/cursor-color-picker.png", + &error); + if (!pixbuf) + { + g_critical ("gdk_pixbuf_new_from_resource failed: %s", + error ? error->message : "unknown error"); + goto cleanup; + } + g_clear_error (&error); + + cursor = create_cursor_from_rgba32_pixbuf (pixbuf, (POINT){ 1, 30 }); + +cleanup: + g_clear_error (&error); + g_clear_object (&pixbuf); + + return cursor; +} + +/* }}} + * {{{ Low-level mouse hook */ + +/* This mouse procedure can detect clicks made on any + * application window. Countrary to mouse capture, this + * method continues to work even after switching active + * windows. */ + +static LRESULT CALLBACK +mouse_procedure (int nCode, + WPARAM wParam, + LPARAM lParam) +{ + if (nCode == HC_ACTION) + { + MSLLHOOKSTRUCT *info = (MSLLHOOKSTRUCT*) lParam; + + switch (wParam) + { + case WM_LBUTTONDOWN: + case WM_MBUTTONDOWN: + case WM_RBUTTONDOWN: + case WM_XBUTTONDOWN: + { + POINT physical; + MonitorData *data; + + if (pickers == NULL) + break; + + /* A low-level mouse hook always receives points in + * per-monitor DPI-aware screen coordinates, regardless of + * the DPI awareness setting of the application. */ + physical = info->pt; + + data = monitors_find_for_physical_point (physical); + if (!data) + g_message ("Captured point (%ld, %ld) doesn't belong to any monitor", + (long) physical.x, (long) physical.y); + + user_picked (data, physical); + + /* It's safe to remove a hook from within its callback. + * Anyway this can even be called from an idle callback, + * as the hook does nothing if there are no pickers. + * (In that case also the ensure functions have to be + * scheduled in an idle callback) */ + stop_picking (); + + return (wParam == WM_XBUTTONDOWN) ? TRUE : 0; + } + break; + default: + break; + } + } + + return CallNextHookEx (NULL, nCode, wParam, lParam); +} + +static gboolean +ensure_mouse_hook (void) +{ + if (!mouse_hook) + { + mouse_hook = SetWindowsHookEx (WH_MOUSE_LL, mouse_procedure, this_module (), 0); + if (!mouse_hook) + { + g_warning ("SetWindowsHookEx failed with error code %u", + (unsigned) GetLastError ()); + return FALSE; + } + } + + return TRUE; +} + +static void +remove_mouse_hook (void) +{ + if (mouse_hook) + { + if (!UnhookWindowsHookEx (mouse_hook)) + { + g_warning ("UnhookWindowsHookEx failed with error code %u", + (unsigned) GetLastError ()); + return; + } + + mouse_hook = NULL; + } +} + +/* }}} + * {{{ Low-level keyboard hook */ + +/* This is used to stop picking anytime the user presses ESC */ + +static LRESULT CALLBACK +keyboard_procedure (int nCode, + WPARAM wParam, + LPARAM lParam) +{ + if (nCode == HC_ACTION) + { + KBDLLHOOKSTRUCT *info = (KBDLLHOOKSTRUCT*) lParam; + + switch (wParam) + { + case WM_KEYDOWN: + case WM_SYSKEYDOWN: + if (info->vkCode == VK_ESCAPE) + { + stop_picking (); + return 1; + } + break; + default: + break; + } + } + + return CallNextHookEx(NULL, nCode, wParam, lParam); +} + +static gboolean +ensure_keyboard_hook (void) +{ + if (!keyboard_hook) + { + keyboard_hook = SetWindowsHookEx (WH_KEYBOARD_LL, keyboard_procedure, this_module (), 0); + if (!keyboard_hook) + { + g_warning ("SetWindowsHookEx failed with error code %u", + (unsigned) GetLastError ()); + return FALSE; + } + } + + return TRUE; +} + +static void +remove_keyboard_hook (void) +{ + if (keyboard_hook) + { + if (!UnhookWindowsHookEx (keyboard_hook)) + { + g_warning ("UnhookWindowsHookEx failed with error code %u", + (unsigned) GetLastError ()); + return; + } + + keyboard_hook = NULL; + } +} + +/* }}} + * {{{ Input-only windows */ + +/* Those input-only windows are placed to cover each monitor on + * the screen and serve two purposes: display our custom mouse + * cursor and freeze the desktop by avoiding interaction of the + * mouse with other applications */ + +static LRESULT CALLBACK +input_window_procedure (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam) +{ + switch (uMsg) + { + case WM_NCCREATE: + /* The shell automatically hides the taskbar when a window + * covers the entire area of a monitor (fullscreened). In + * order to avoid that, we can set a special property on + * the window + * See the docs for ITaskbarList2::MarkFullscreenWindow() + * on MSDN for more informations */ + + if (!SetPropW (hwnd, L"NonRudeHWND", (HANDLE) TRUE)) + g_warning_once ("SetPropW failed with error code %u", + (unsigned) GetLastError ()); + break; + + case WM_NCDESTROY: + /* We have to remove window properties manually before the + * window gets destroyed */ + + if (!RemovePropW (hwnd, L"NonRudeHWND")) + g_warning_once ("SetPropW failed with error code %u", + (unsigned) GetLastError ()); + break; + + /* Avoid any drawing at all. Here we block processing of the + * default window procedure, although we set the NULL_BRUSH + * as the window class's background brush, so even the default + * window procedure wouldn't draw anything at all */ + + case WM_ERASEBKGND: + return 1; + case WM_PAINT: + { + #if 1 + PAINTSTRUCT ps; + BeginPaint(hwnd, &ps); + EndPaint(hwnd, &ps); + #else + UINT flags = RDW_VALIDATE | + RDW_NOFRAME | + RDW_NOERASE; + RedrawWindow (hwnd, NULL, NULL, flags); + #endif + } + return 0; + #if 0 + case WM_SYNCPAINT: + return 0; + #endif + + case WM_MOUSEACTIVATE: + /* This can be useful in case we want to avoid + * using a mouse hook */ + return MA_NOACTIVATE; + + /* Anytime we detect a mouse click, pick the color. Note that + * this is rarely used as the mouse hook would process the + * clicks before that */ + + case WM_LBUTTONDOWN: + case WM_MBUTTONDOWN: + case WM_RBUTTONDOWN: + case WM_XBUTTONDOWN: + { + POINT logical = (POINT){GET_X_LPARAM (lParam), GET_Y_LPARAM (lParam)}; + MonitorData *data = monitors_find_for_logical_point (logical); + POINT physical = logical_to_physical (data, logical); + + if (!data) + g_message ("Captured point (%ld, %ld) doesn't belong to any monitor", + (long) logical.x, (long) logical.y); + + user_picked (data, physical); + + stop_picking (); + } + + return (uMsg == WM_XBUTTONDOWN) ? TRUE : 0; + default: + break; + } + + return DefWindowProcW (hwnd, uMsg, wParam, lParam); +} + +static gboolean +ensure_input_window_class (void) +{ + if (!input_window_class) + { + WNDCLASSEXW wndclassex; + HCURSOR cursor = create_cursor (); + + memset (&wndclassex, 0, sizeof (wndclassex)); + wndclassex.cbSize = sizeof (wndclassex); + wndclassex.hInstance = this_module (); + wndclassex.lpszClassName = L"GimpPickButtonInputWindowClass"; + wndclassex.lpfnWndProc = input_window_procedure; + wndclassex.hbrBackground = GetStockObject (NULL_BRUSH); + wndclassex.hCursor = cursor ? + cursor : + LoadImageW (NULL, + (LPCWSTR)(guintptr)IDC_CROSS, + IMAGE_CURSOR, 0, 0, + LR_DEFAULTSIZE | LR_SHARED); + + input_window_class = RegisterClassExW (&wndclassex); + if (input_window_class == 0) + { + g_warning ("RegisterClassExW failed with error code %u", + (unsigned) GetLastError ()); + + if (cursor) + DestroyCursor (cursor); + + return FALSE; + } + } + + return TRUE; +} + +static void +remove_input_window_class (void) +{ + if (input_window_class) + { + LPCWSTR name = (LPCWSTR)(guintptr)input_window_class; + UnregisterClassW (name, this_module ()); + input_window_class = 0; + } +} + +/* create_input_window expects logical screen coordinates */ + +static HWND +create_input_window (POINT origin, + int width, + int height) +{ + DWORD stylex = WS_EX_NOACTIVATE | WS_EX_TOPMOST; + LPCWSTR wclass; + LPCWSTR title = L"Gimp Input Window"; + DWORD style = WS_POPUP; + HWND hwnd; + + if (!ensure_input_window_class ()) + return FALSE; + + /* This must go after the ensure_input_window_class */ + wclass = (LPCWSTR)(guintptr)input_window_class; + + hwnd = CreateWindowExW (stylex, wclass, title, style, + origin.x, origin.y, width, height, + NULL, NULL, this_module (), NULL); + if (hwnd == NULL) + { + g_warning_once ("CreateWindowExW failed with error code %u", + (unsigned) GetLastError ()); + return FALSE; + } + + ShowWindow (hwnd, SW_SHOWNOACTIVATE); + + return hwnd; +} + +/* }}} + * {{{ Hidden notification window */ + +/* We setup a hidden window to listen for WM_DISPLAYCAHNGE + * messages and reposition the input-only windows on the + * screen */ + +static LRESULT CALLBACK +notif_window_procedure (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam) +{ + switch (uMsg) + { + case WM_DISPLAYCHANGE: + screen_changed (); + break; + default: + break; + } + + return DefWindowProcW (hwnd, uMsg, wParam, lParam); +} + +static gboolean +ensure_notif_window_class (void) +{ + if (!notif_window_class) + { + WNDCLASSEXW wndclassex; + + memset (&wndclassex, 0, sizeof (wndclassex)); + wndclassex.cbSize = sizeof (wndclassex); + wndclassex.hInstance = this_module (); + wndclassex.lpszClassName = L"GimpPickButtonNotifWindowClass"; + wndclassex.lpfnWndProc = notif_window_procedure; + + notif_window_class = RegisterClassExW (&wndclassex); + if (notif_window_class == 0) + { + g_warning ("RegisterClassExW failed with error code %u", + (unsigned) GetLastError ()); + return FALSE; + } + } + + return TRUE; +} + +static void +remove_notif_window_class (void) +{ + if (notif_window_class) + { + LPCWSTR name = (LPCWSTR)(guintptr)notif_window_class; + UnregisterClassW (name, this_module ()); + notif_window_class = 0; + } +} + +static gboolean +ensure_notif_window (void) +{ + if (!ensure_notif_window_class ()) + return FALSE; + + if (!notif_window_handle) + { + DWORD stylex = 0; + LPCWSTR wclass = (LPCWSTR)(guintptr)notif_window_class; + LPCWSTR title = L"Gimp Notifications Window"; + DWORD style = WS_POPUP; + + notif_window_handle = CreateWindowExW (stylex, wclass, + title, style, + 0, 0, 1, 1, + NULL, NULL, + this_module (), + NULL); + if (notif_window_handle == NULL) + { + g_warning_once ("CreateWindowExW failed with error code %u", + (unsigned) GetLastError ()); + return FALSE; + } + } + + return TRUE; +} + +static void +remove_notif_window (void) +{ + if (notif_window_handle) + { + DestroyWindow (notif_window_handle); + notif_window_handle = NULL; + } + + remove_notif_window_class (); +} + +/* }}} + * {{{ Monitor enumeration and discovery */ + +static void +monitor_data_free (gpointer ptr) +{ + MonitorData *data = (MonitorData*) ptr; + + if (data->device) + free (data->device); +} + +static BOOL CALLBACK +enum_monitor_callback (HMONITOR hMonitor, + HDC hDC, + RECT *pRect, + LPARAM lParam) +{ + GArray *result = (GArray*) lParam; + MonitorData data; + MONITORINFOEXW info; + DEVMODEW devmode; + + const BOOL CALLBACK_CONTINUE = TRUE; + const BOOL CALLBACK_STOP = FALSE; + + if (!pRect) + return CALLBACK_CONTINUE; + + if (IsRectEmpty (pRect)) + return CALLBACK_CONTINUE; + + memset (&data, 0, sizeof (data)); + data.handle = hMonitor; + data.hdc = hDC; + data.screen_origin.x = pRect->left; + data.screen_origin.y = pRect->top; + data.logical_width = pRect->right - pRect->left; + data.logical_height = pRect->bottom - pRect->top; + + memset (&info, 0, sizeof (info)); + info.cbSize = sizeof (info); + if (!GetMonitorInfoW (hMonitor, (MONITORINFO*) &info)) + { + g_warning_once ("GetMonitorInfo failed with error code %u", + (unsigned) GetLastError ()); + return CALLBACK_CONTINUE; + } + + data.device = _wcsdup (info.szDevice); + + memset (&devmode, 0, sizeof (devmode)); + devmode.dmSize = sizeof (devmode); + if (!EnumDisplaySettingsExW (info.szDevice, + ENUM_CURRENT_SETTINGS, + &devmode, EDS_ROTATEDMODE)) + { + g_warning_once ("EnumDisplaySettingsEx failed with error code %u", + (unsigned) GetLastError ()); + return CALLBACK_CONTINUE; + } + + if (devmode.dmPelsWidth) + data.physical_width = devmode.dmPelsWidth; + + if (devmode.dmPelsHeight) + data.physical_height = devmode.dmPelsHeight; + + g_array_append_val (result, data); + + if (result->len >= 100) + return CALLBACK_STOP; + + return CALLBACK_CONTINUE; +} + +static GArray* +enumerate_monitors (void) +{ + int count_monitors; + guint length_hint; + GArray *result; + + count_monitors = GetSystemMetrics (SM_CMONITORS); + + if (count_monitors > 0 && count_monitors < 100) + length_hint = (guint) count_monitors; + else + length_hint = 1; + + result = g_array_sized_new (FALSE, TRUE, sizeof (MonitorData), length_hint); + g_array_set_clear_func (result, monitor_data_free); + + if (!EnumDisplayMonitors (NULL, NULL, enum_monitor_callback, (LPARAM) result)) + { + g_warning ("EnumDisplayMonitors failed with error code %u", + (unsigned) GetLastError ()); + } + + return result; +} + +static void +ensure_input_windows (void) +{ + ensure_monitors (); + + if (!input_window_handles) + { + guint i; + + input_window_handles = g_array_sized_new (FALSE, TRUE, + sizeof (HWND), + monitors->len); + g_array_set_clear_func (input_window_handles, destroy_window); + + for (i = 0; i < monitors->len; i++) + { + MonitorData *data = &g_array_index (monitors, MonitorData, i); + HWND hwnd = create_input_window (data->screen_origin, + data->logical_width, + data->logical_height); + + if (hwnd) + g_array_append_val (input_window_handles, hwnd); + } + } +} + +static void +remove_input_windows (void) +{ + if (input_window_handles) + { + g_array_free (input_window_handles, TRUE); + input_window_handles = NULL; + } +} + +static void +ensure_monitors (void) +{ + if (!monitors) + monitors = enumerate_monitors (); +} + +static void +remove_monitors (void) +{ + if (monitors) + { + g_array_free (monitors, TRUE); + monitors = NULL; + } +} + +static void +ensure_screen_data (void) +{ + ensure_monitors (); + ensure_input_windows (); +} + +static void +remove_screen_data (void) +{ + remove_input_windows (); + remove_monitors (); +} + +static void +screen_changed (void) +{ + remove_screen_data (); + ensure_screen_data (); +} + +static void +ensure_screen_tracking (void) +{ + ensure_notif_window (); + screen_changed (); +} + +static void +remove_screen_tracking (void) +{ + remove_notif_window (); + remove_screen_data (); +} + +/* }}} + * {{{ GimpPickButtonWin32 */ + +/* pick_color_with_gdi is based on the GDI GetPixel() function. + * Note that GDI only returns 8bit per-channel color data, but + * as of today there's no documented method to retrieve colors + * at higher bit depths. */ + +static GimpRGB +pick_color_with_gdi (POINT physical_point) +{ + GimpRGB rgb; + COLORREF color; + HDC hdc; + + hdc = GetDC (HWND_DESKTOP); + + if (!(GetDeviceCaps (hdc, RASTERCAPS) & RC_BITBLT)) + g_warning_once ("RC_BITBLT capability missing from device context"); + + color = GetPixel (hdc, physical_point.x, physical_point.y); + + gimp_rgba_set_uchar (&rgb, GetRValue (color), GetGValue (color), GetBValue (color), 255); + + ReleaseDC (HWND_DESKTOP, hdc); + + return rgb; +} + +static void +user_picked (MonitorData *monitor, + POINT physical_point) +{ + GimpRGB rgb; + GList *l; + + /* Currently unused */ + (void) monitor; + + rgb = pick_color_with_gdi (physical_point); + + for (l = pickers; l != NULL; l = l->next) + { + GimpPickButton *button = GIMP_PICK_BUTTON (l->data); + g_signal_emit_by_name (button, "color-picked", &rgb); + } +} + +/* entry point to this file, called from gimppickbutton.c */ +void +_gimp_pick_button_win32_pick (GimpPickButton *button) +{ + ensure_mouse_hook (); + ensure_keyboard_hook (); + ensure_screen_tracking (); + + if (g_list_find (pickers, button)) + return; + + pickers = g_list_prepend (pickers, + g_object_ref (button)); +} + +static void +stop_picking (void) +{ + remove_screen_tracking (); + remove_keyboard_hook (); + remove_mouse_hook (); + + g_list_free_full (pickers, g_object_unref); + pickers = NULL; +} |