/* GDK - The GIMP Drawing Kit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * Copyright (C) 1998-2002 Tor Lillqvist * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * 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 * Lesser 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 . */ #include "config.h" #define GDK_PIXBUF_ENABLE_BACKEND /* Ugly? */ #include "gdkdisplay.h" #include "gdkscreen.h" #include "gdkcursor.h" #include "gdkwin32.h" #ifdef __MINGW32__ #include #endif #include "xcursors.h" #if (defined(__MINGW32__) && (__W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 8))) || (defined(_MSC_VER) && (WINVER < 0x0500)) typedef struct { DWORD bV5Size; LONG bV5Width; LONG bV5Height; WORD bV5Planes; WORD bV5BitCount; DWORD bV5Compression; DWORD bV5SizeImage; LONG bV5XPelsPerMeter; LONG bV5YPelsPerMeter; DWORD bV5ClrUsed; DWORD bV5ClrImportant; DWORD bV5RedMask; DWORD bV5GreenMask; DWORD bV5BlueMask; DWORD bV5AlphaMask; DWORD bV5CSType; CIEXYZTRIPLE bV5Endpoints; DWORD bV5GammaRed; DWORD bV5GammaGreen; DWORD bV5GammaBlue; DWORD bV5Intent; DWORD bV5ProfileData; DWORD bV5ProfileSize; DWORD bV5Reserved; } BITMAPV5HEADER; #endif static HCURSOR hcursor_from_type (GdkCursorType cursor_type) { gint i, j, x, y, ofs; HCURSOR rv; gint w, h; guchar *and_plane, *xor_plane; if (cursor_type != GDK_BLANK_CURSOR) { for (i = 0; i < G_N_ELEMENTS (cursors); i++) if (cursors[i].type == cursor_type) break; if (i >= G_N_ELEMENTS (cursors) || !cursors[i].name) return NULL; /* Use real Win32 cursor if possible */ if (cursors[i].builtin) return LoadCursor (NULL, cursors[i].builtin); } w = GetSystemMetrics (SM_CXCURSOR); h = GetSystemMetrics (SM_CYCURSOR); and_plane = g_malloc ((w/8) * h); memset (and_plane, 0xff, (w/8) * h); xor_plane = g_malloc ((w/8) * h); memset (xor_plane, 0, (w/8) * h); if (cursor_type != GDK_BLANK_CURSOR) { #define SET_BIT(v,b) (v |= (1 << b)) #define RESET_BIT(v,b) (v &= ~(1 << b)) for (j = 0, y = 0; y < cursors[i].height && y < h ; y++) { ofs = (y * w) / 8; j = y * cursors[i].width; for (x = 0; x < cursors[i].width && x < w ; x++, j++) { gint pofs = ofs + x / 8; guchar data = (cursors[i].data[j/4] & (0xc0 >> (2 * (j%4)))) >> (2 * (3 - (j%4))); gint bit = 7 - (j % cursors[i].width) % 8; if (data) { RESET_BIT (and_plane[pofs], bit); if (data == 1) SET_BIT (xor_plane[pofs], bit); } } } #undef SET_BIT #undef RESET_BIT rv = CreateCursor (_gdk_app_hmodule, cursors[i].hotx, cursors[i].hoty, w, h, and_plane, xor_plane); } else { rv = CreateCursor (_gdk_app_hmodule, 0, 0, w, h, and_plane, xor_plane); } if (rv == NULL) WIN32_API_FAILED ("CreateCursor"); g_free (and_plane); g_free (xor_plane); return rv; } struct _GdkWin32CursorClass { GdkCursorClass cursor_class; }; G_DEFINE_TYPE (GdkWin32Cursor, gdk_win32_cursor, GDK_TYPE_CURSOR) static void _gdk_win32_cursor_finalize (GObject *object) { GdkWin32Cursor *private = GDK_WIN32_CURSOR (object); if (GetCursor () == private->hcursor) SetCursor (NULL); if (!DestroyCursor (private->hcursor)) WIN32_API_FAILED ("DestroyCursor"); G_OBJECT_CLASS (gdk_win32_cursor_parent_class)->finalize (object); } static GdkCursor* cursor_new_from_hcursor (HCURSOR hcursor, GdkCursorType cursor_type) { GdkWin32Cursor *private; GdkCursor *cursor; private = g_object_new (GDK_TYPE_WIN32_CURSOR, "cursor-type", cursor_type, "display", _gdk_display, NULL); private->hcursor = hcursor; cursor = (GdkCursor*) private; return cursor; } GdkCursor* _gdk_win32_display_get_cursor_for_type (GdkDisplay *display, GdkCursorType cursor_type) { HCURSOR hcursor; g_return_val_if_fail (display == _gdk_display, NULL); hcursor = hcursor_from_type (cursor_type); if (hcursor == NULL) g_warning ("gdk_cursor_new_for_display: no cursor %d found", cursor_type); else GDK_NOTE (CURSOR, g_print ("gdk_cursor_new_for_display: %d: %p\n", cursor_type, hcursor)); return cursor_new_from_hcursor (hcursor, cursor_type); } /* FIXME: The named cursors below are presumably not really useful, as * the names are Win32-specific. No GTK+ application developed on Unix * (and most cross-platform GTK+ apps are developed on Unix) is going * to look for cursors under these Win32 names anyway. * * Would the following make any sense: The ms-windows theme engine * calls some (to-be-defined private) API here in gdk/win32 to * register the relevant cursors used by the currently active XP * visual style under the names that libgtk uses to look for them * ("color-picker", "dnd-ask", "dnd-copy", etc), and then when libgtk * asks for those we return the ones registered by the ms-windows * theme engine, if any. */ static struct { char *name; char *id; } default_cursors[] = { { "appstarting", IDC_APPSTARTING }, { "arrow", IDC_ARROW }, { "cross", IDC_CROSS }, #ifdef IDC_HAND { "hand", IDC_HAND }, #endif { "help", IDC_HELP }, { "ibeam", IDC_IBEAM }, { "sizeall", IDC_SIZEALL }, { "sizenesw", IDC_SIZENESW }, { "sizens", IDC_SIZENS }, { "sizenwse", IDC_SIZENWSE }, { "sizewe", IDC_SIZEWE }, { "uparrow", IDC_UPARROW }, { "wait", IDC_WAIT } }; GdkCursor* _gdk_win32_display_get_cursor_for_name (GdkDisplay *display, const gchar *name) { HCURSOR hcursor = NULL; int i; g_return_val_if_fail (display == _gdk_display, NULL); for (i = 0; i < G_N_ELEMENTS(default_cursors); i++) { if (0 == strcmp(default_cursors[i].name, name)) hcursor = LoadCursor (NULL, default_cursors[i].id); } /* allow to load named cursor resources linked into the executable */ if (!hcursor) hcursor = LoadCursor (_gdk_app_hmodule, name); if (hcursor) return cursor_new_from_hcursor (hcursor, GDK_X_CURSOR); return NULL; } GdkPixbuf * gdk_win32_icon_to_pixbuf_libgtk_only (HICON hicon) { GdkPixbuf *pixbuf = NULL; ICONINFO ii; struct { BITMAPINFOHEADER bi; RGBQUAD colors[2]; } bmi; HDC hdc; guchar *pixels, *bits; gchar buf[32]; gint rowstride, x, y, w, h; if (!GDI_CALL (GetIconInfo, (hicon, &ii))) return NULL; if (!(hdc = CreateCompatibleDC (NULL))) { WIN32_GDI_FAILED ("CreateCompatibleDC"); goto out0; } memset (&bmi, 0, sizeof (bmi)); bmi.bi.biSize = sizeof (bmi.bi); if (ii.hbmColor != NULL) { /* Colour cursor */ gboolean no_alpha; if (!GDI_CALL (GetDIBits, (hdc, ii.hbmColor, 0, 1, NULL, (BITMAPINFO *)&bmi, DIB_RGB_COLORS))) goto out1; w = bmi.bi.biWidth; h = bmi.bi.biHeight; bmi.bi.biBitCount = 32; bmi.bi.biCompression = BI_RGB; bmi.bi.biHeight = -h; bits = g_malloc0 (4 * w * h); /* color data */ if (!GDI_CALL (GetDIBits, (hdc, ii.hbmColor, 0, h, bits, (BITMAPINFO *)&bmi, DIB_RGB_COLORS))) goto out2; pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, w, h); pixels = gdk_pixbuf_get_pixels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); no_alpha = TRUE; for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { pixels[2] = bits[(x+y*w) * 4]; pixels[1] = bits[(x+y*w) * 4 + 1]; pixels[0] = bits[(x+y*w) * 4 + 2]; pixels[3] = bits[(x+y*w) * 4 + 3]; if (no_alpha && pixels[3] > 0) no_alpha = FALSE; pixels += 4; } pixels += (w * 4 - rowstride); } /* mask */ if (no_alpha && GDI_CALL (GetDIBits, (hdc, ii.hbmMask, 0, h, bits, (BITMAPINFO *)&bmi, DIB_RGB_COLORS))) { pixels = gdk_pixbuf_get_pixels (pixbuf); for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { pixels[3] = 255 - bits[(x + y * w) * 4]; pixels += 4; } pixels += (w * 4 - rowstride); } } } else { /* B&W cursor */ int bpl; if (!GDI_CALL (GetDIBits, (hdc, ii.hbmMask, 0, 0, NULL, (BITMAPINFO *)&bmi, DIB_RGB_COLORS))) goto out1; w = bmi.bi.biWidth; h = ABS (bmi.bi.biHeight) / 2; bits = g_malloc0 (4 * w * h); /* masks */ if (!GDI_CALL (GetDIBits, (hdc, ii.hbmMask, 0, h*2, bits, (BITMAPINFO *)&bmi, DIB_RGB_COLORS))) goto out2; pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, w, h); pixels = gdk_pixbuf_get_pixels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); bpl = ((w-1)/32 + 1)*4; #if 0 for (y = 0; y < h*2; y++) { for (x = 0; x < w; x++) { const gint bit = 7 - (x % 8); printf ("%c ", ((bits[bpl*y+x/8])&(1<hcursor); } GdkCursor * _gdk_win32_display_get_cursor_for_pixbuf (GdkDisplay *display, GdkPixbuf *pixbuf, gint x, gint y) { HCURSOR hcursor; g_return_val_if_fail (display == _gdk_display, NULL); g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); g_return_val_if_fail (0 <= x && x < gdk_pixbuf_get_width (pixbuf), NULL); g_return_val_if_fail (0 <= y && y < gdk_pixbuf_get_height (pixbuf), NULL); hcursor = _gdk_win32_pixbuf_to_hcursor (pixbuf, x, y); if (!hcursor) return NULL; return cursor_new_from_hcursor (hcursor, GDK_CURSOR_IS_PIXMAP); } gboolean _gdk_win32_display_supports_cursor_alpha (GdkDisplay *display) { g_return_val_if_fail (display == _gdk_display, FALSE); return _gdk_win32_pixbuf_to_hicon_supports_alpha (); } gboolean _gdk_win32_display_supports_cursor_color (GdkDisplay *display) { g_return_val_if_fail (display == _gdk_display, FALSE); return TRUE; } void _gdk_win32_display_get_default_cursor_size (GdkDisplay *display, guint *width, guint *height) { g_return_if_fail (display == _gdk_display); if (width) *width = GetSystemMetrics (SM_CXCURSOR); if (height) *height = GetSystemMetrics (SM_CYCURSOR); } void _gdk_win32_display_get_maximal_cursor_size (GdkDisplay *display, guint *width, guint *height) { g_return_if_fail (display == _gdk_display); if (width) *width = GetSystemMetrics (SM_CXCURSOR); if (height) *height = GetSystemMetrics (SM_CYCURSOR); } /* Convert a pixbuf to an HICON (or HCURSOR). Supports alpha under * Windows XP, thresholds alpha otherwise. Also used from * gdkwindow-win32.c for creating application icons. */ static HBITMAP create_alpha_bitmap (gint size, guchar **outdata) { BITMAPV5HEADER bi; HDC hdc; HBITMAP hBitmap; ZeroMemory (&bi, sizeof (BITMAPV5HEADER)); bi.bV5Size = sizeof (BITMAPV5HEADER); bi.bV5Height = bi.bV5Width = size; bi.bV5Planes = 1; bi.bV5BitCount = 32; bi.bV5Compression = BI_BITFIELDS; /* The following mask specification specifies a supported 32 BPP * alpha format for Windows XP (BGRA format). */ bi.bV5RedMask = 0x00FF0000; bi.bV5GreenMask = 0x0000FF00; bi.bV5BlueMask = 0x000000FF; bi.bV5AlphaMask = 0xFF000000; /* Create the DIB section with an alpha channel. */ hdc = GetDC (NULL); if (!hdc) { WIN32_GDI_FAILED ("GetDC"); return NULL; } hBitmap = CreateDIBSection (hdc, (BITMAPINFO *)&bi, DIB_RGB_COLORS, (PVOID *) outdata, NULL, (DWORD)0); if (hBitmap == NULL) WIN32_GDI_FAILED ("CreateDIBSection"); ReleaseDC (NULL, hdc); return hBitmap; } static HBITMAP create_color_bitmap (gint size, guchar **outdata, gint bits) { struct { BITMAPV4HEADER bmiHeader; RGBQUAD bmiColors[2]; } bmi; HDC hdc; HBITMAP hBitmap; ZeroMemory (&bmi, sizeof (bmi)); bmi.bmiHeader.bV4Size = sizeof (BITMAPV4HEADER); bmi.bmiHeader.bV4Height = bmi.bmiHeader.bV4Width = size; bmi.bmiHeader.bV4Planes = 1; bmi.bmiHeader.bV4BitCount = bits; bmi.bmiHeader.bV4V4Compression = BI_RGB; /* when bits is 1, these will be used. * bmiColors[0] already zeroed from ZeroMemory() */ bmi.bmiColors[1].rgbBlue = 0xFF; bmi.bmiColors[1].rgbGreen = 0xFF; bmi.bmiColors[1].rgbRed = 0xFF; hdc = GetDC (NULL); if (!hdc) { WIN32_GDI_FAILED ("GetDC"); return NULL; } hBitmap = CreateDIBSection (hdc, (BITMAPINFO *)&bmi, DIB_RGB_COLORS, (PVOID *) outdata, NULL, (DWORD)0); if (hBitmap == NULL) WIN32_GDI_FAILED ("CreateDIBSection"); ReleaseDC (NULL, hdc); return hBitmap; } static gboolean pixbuf_to_hbitmaps_alpha_winxp (GdkPixbuf *pixbuf, HBITMAP *color, HBITMAP *mask) { /* Based on code from * http://www.dotnet247.com/247reference/msgs/13/66301.aspx */ HBITMAP hColorBitmap, hMaskBitmap; guchar *indata, *inrow; guchar *colordata, *colorrow, *maskdata, *maskbyte; gint width, height, size, i, i_offset, j, j_offset, rowstride; guint maskstride, mask_bit; width = gdk_pixbuf_get_width (pixbuf); /* width of icon */ height = gdk_pixbuf_get_height (pixbuf); /* height of icon */ /* The bitmaps are created square */ size = MAX (width, height); hColorBitmap = create_alpha_bitmap (size, &colordata); if (!hColorBitmap) return FALSE; hMaskBitmap = create_color_bitmap (size, &maskdata, 1); if (!hMaskBitmap) { DeleteObject (hColorBitmap); return FALSE; } /* MSDN says mask rows are aligned to "LONG" boundaries */ maskstride = (((size + 31) & ~31) >> 3); indata = gdk_pixbuf_get_pixels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); 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++) { colorrow = colordata + 4*(j+j_offset)*size + 4*i_offset; maskbyte = maskdata + (j+j_offset)*maskstride + i_offset/8; mask_bit = (0x80 >> (i_offset % 8)); inrow = indata + (height-j-1)*rowstride; for (i = 0; i < width; i++) { colorrow[4*i+0] = inrow[4*i+2]; colorrow[4*i+1] = inrow[4*i+1]; colorrow[4*i+2] = inrow[4*i+0]; colorrow[4*i+3] = inrow[4*i+3]; if (inrow[4*i+3] == 0) maskbyte[0] |= mask_bit; /* turn ON bit */ else maskbyte[0] &= ~mask_bit; /* turn OFF bit */ mask_bit >>= 1; if (mask_bit == 0) { mask_bit = 0x80; maskbyte++; } } } *color = hColorBitmap; *mask = hMaskBitmap; return TRUE; } static gboolean pixbuf_to_hbitmaps_normal (GdkPixbuf *pixbuf, HBITMAP *color, HBITMAP *mask) { /* Based on code from * http://www.dotnet247.com/247reference/msgs/13/66301.aspx */ HBITMAP hColorBitmap, hMaskBitmap; guchar *indata, *inrow; guchar *colordata, *colorrow, *maskdata, *maskbyte; gint width, height, size, i, i_offset, j, j_offset, rowstride, nc, bmstride; gboolean has_alpha; guint maskstride, mask_bit; width = gdk_pixbuf_get_width (pixbuf); /* width of icon */ height = gdk_pixbuf_get_height (pixbuf); /* height of icon */ /* The bitmaps are created square */ size = MAX (width, height); hColorBitmap = create_color_bitmap (size, &colordata, 24); if (!hColorBitmap) return FALSE; hMaskBitmap = create_color_bitmap (size, &maskdata, 1); if (!hMaskBitmap) { DeleteObject (hColorBitmap); return FALSE; } /* rows are always aligned on 4-byte boundarys */ bmstride = size * 3; if (bmstride % 4 != 0) bmstride += 4 - (bmstride % 4); /* MSDN says mask rows are aligned to "LONG" boundaries */ maskstride = (((size + 31) & ~31) >> 3); indata = gdk_pixbuf_get_pixels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); nc = gdk_pixbuf_get_n_channels (pixbuf); has_alpha = gdk_pixbuf_get_has_alpha (pixbuf); 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++) { colorrow = colordata + (j+j_offset)*bmstride + 3*i_offset; maskbyte = maskdata + (j+j_offset)*maskstride + i_offset/8; mask_bit = (0x80 >> (i_offset % 8)); inrow = indata + (height-j-1)*rowstride; for (i = 0; i < width; i++) { if (has_alpha && inrow[nc*i+3] < 128) { colorrow[3*i+0] = colorrow[3*i+1] = colorrow[3*i+2] = 0; maskbyte[0] |= mask_bit; /* turn ON bit */ } else { colorrow[3*i+0] = inrow[nc*i+2]; colorrow[3*i+1] = inrow[nc*i+1]; colorrow[3*i+2] = inrow[nc*i+0]; maskbyte[0] &= ~mask_bit; /* turn OFF bit */ } mask_bit >>= 1; if (mask_bit == 0) { mask_bit = 0x80; maskbyte++; } } } *color = hColorBitmap; *mask = hMaskBitmap; return TRUE; } static HICON pixbuf_to_hicon (GdkPixbuf *pixbuf, gboolean is_icon, gint x, gint y) { ICONINFO ii; HICON icon; gboolean success; if (pixbuf == NULL) return NULL; if (_gdk_win32_pixbuf_to_hicon_supports_alpha() && gdk_pixbuf_get_has_alpha (pixbuf)) success = pixbuf_to_hbitmaps_alpha_winxp (pixbuf, &ii.hbmColor, &ii.hbmMask); else success = pixbuf_to_hbitmaps_normal (pixbuf, &ii.hbmColor, &ii.hbmMask); if (!success) return NULL; ii.fIcon = is_icon; ii.xHotspot = x; ii.yHotspot = y; icon = CreateIconIndirect (&ii); DeleteObject (ii.hbmColor); DeleteObject (ii.hbmMask); return icon; } HICON _gdk_win32_pixbuf_to_hicon (GdkPixbuf *pixbuf) { return pixbuf_to_hicon (pixbuf, TRUE, 0, 0); } HICON _gdk_win32_pixbuf_to_hcursor (GdkPixbuf *pixbuf, gint x_hotspot, gint y_hotspot) { return pixbuf_to_hicon (pixbuf, FALSE, x_hotspot, y_hotspot); } gboolean _gdk_win32_pixbuf_to_hicon_supports_alpha (void) { static gboolean is_win_xp=FALSE, is_win_xp_checked=FALSE; if (!is_win_xp_checked) { OSVERSIONINFO version; is_win_xp_checked = TRUE; memset (&version, 0, sizeof (version)); version.dwOSVersionInfoSize = sizeof (version); is_win_xp = GetVersionEx (&version) && version.dwPlatformId == VER_PLATFORM_WIN32_NT && (version.dwMajorVersion > 5 || (version.dwMajorVersion == 5 && version.dwMinorVersion >= 1)); } return is_win_xp; } HICON gdk_win32_pixbuf_to_hicon_libgtk_only (GdkPixbuf *pixbuf) { return _gdk_win32_pixbuf_to_hicon (pixbuf); } static void gdk_win32_cursor_init (GdkWin32Cursor *cursor) { } static void gdk_win32_cursor_class_init(GdkWin32CursorClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GdkCursorClass *cursor_class = GDK_CURSOR_CLASS (klass); object_class->finalize = _gdk_win32_cursor_finalize; cursor_class->get_image = _gdk_win32_cursor_get_image; }