object_class->finalize = gdk_drawable_impl_win32_finalize;
- drawable_class->create_gc = _gdk_win32_gc_new;
-
drawable_class->ref_cairo_surface = gdk_win32_ref_cairo_surface;
drawable_class->set_colormap = gdk_win32_set_colormap;
/* Drawing
*/
-static int
-rop2_to_rop3 (int rop2)
-{
- switch (rop2)
- {
- /* Oh, Microsoft's silly names for binary and ternary rops. */
-#define CASE(rop2,rop3) case R2_##rop2: return rop3
- CASE (BLACK, BLACKNESS);
- CASE (NOTMERGEPEN, NOTSRCERASE);
- CASE (MASKNOTPEN, 0x00220326);
- CASE (NOTCOPYPEN, NOTSRCCOPY);
- CASE (MASKPENNOT, SRCERASE);
- CASE (NOT, DSTINVERT);
- CASE (XORPEN, SRCINVERT);
- CASE (NOTMASKPEN, 0x007700E6);
- CASE (MASKPEN, SRCAND);
- CASE (NOTXORPEN, 0x00990066);
- CASE (NOP, 0x00AA0029);
- CASE (MERGENOTPEN, MERGEPAINT);
- CASE (COPYPEN, SRCCOPY);
- CASE (MERGEPENNOT, 0x00DD0228);
- CASE (MERGEPEN, SRCPAINT);
- CASE (WHITE, WHITENESS);
-#undef CASE
- default: return SRCCOPY;
- }
-}
-
-static int
-rop2_to_patblt_rop (int rop2)
-{
- switch (rop2)
- {
-#define CASE(rop2,patblt_rop) case R2_##rop2: return patblt_rop
- CASE (COPYPEN, PATCOPY);
- CASE (XORPEN, PATINVERT);
- CASE (NOT, DSTINVERT);
- CASE (BLACK, BLACKNESS);
- CASE (WHITE, WHITENESS);
-#undef CASE
- default:
- g_warning ("Unhandled rop2 in GC to be used in PatBlt: %#x", rop2);
- return PATCOPY;
- }
-}
-
-static inline int
-align_with_dash_offset (int a, DWORD *dashes, int num_dashes, GdkGCWin32 *gcwin32)
-{
- int n = 0;
- int len_sum = 0;
- /*
- * We can't simply add the dashoffset, it can be an arbitrary larger
- * or smaller value not even between x1 and x2. It just says use the
- * dash pattern aligned to the offset. So ensure x1 is smaller _x1
- * and we start with the appropriate dash.
- */
- for (n = 0; n < num_dashes; n++)
- len_sum += dashes[n];
- if ( len_sum > 0 /* pathological api usage? */
- && gcwin32->pen_dash_offset > a)
- a -= (((gcwin32->pen_dash_offset/len_sum - a/len_sum) + 1) * len_sum);
- else
- a = gcwin32->pen_dash_offset;
-
- return a;
-}
-
-/* Render a dashed line 'by hand'. Used for all dashes on Win9x (where
- * GDI is way too limited), and for double dashes on all Windowses.
- */
-static inline gboolean
-render_line_horizontal (GdkGCWin32 *gcwin32,
- int x1,
- int x2,
- int y)
-{
- int n = 0;
- const int pen_width = MAX (gcwin32->pen_width, 1);
- const int _x1 = x1;
-
- g_assert (gcwin32->pen_dashes);
-
- x1 = align_with_dash_offset (x1, gcwin32->pen_dashes, gcwin32->pen_num_dashes, gcwin32);
-
- for (n = 0; x1 < x2; n++)
- {
- int len = gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- if (x1 + len > x2)
- len = x2 - x1;
-
- if (n % 2 == 0 && x1 + len > _x1)
- if (!GDI_CALL (PatBlt, (gcwin32->hdc,
- x1 < _x1 ? _x1 : x1,
- y - pen_width / 2,
- len, pen_width,
- rop2_to_patblt_rop (gcwin32->rop2))))
- return FALSE;
-
- x1 += gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- }
-
- if (gcwin32->line_style == GDK_LINE_DOUBLE_DASH)
- {
- HBRUSH hbr;
-
- if ((hbr = SelectObject (gcwin32->hdc, gcwin32->pen_hbrbg)) == HGDI_ERROR)
- return FALSE;
- x1 = _x1;
- x1 += gcwin32->pen_dash_offset;
- for (n = 0; x1 < x2; n++)
- {
- int len = gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- if (x1 + len > x2)
- len = x2 - x1;
-
- if (n % 2)
- if (!GDI_CALL (PatBlt, (gcwin32->hdc, x1, y - pen_width / 2,
- len, pen_width,
- rop2_to_patblt_rop (gcwin32->rop2))))
- return FALSE;
-
- x1 += gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- }
- if (SelectObject (gcwin32->hdc, hbr) == HGDI_ERROR)
- return FALSE;
- }
-
- return TRUE;
-}
-
-static inline gboolean
-render_line_vertical (GdkGCWin32 *gcwin32,
- int x,
- int y1,
- int y2)
-{
- int n;
- const int pen_width = MAX (gcwin32->pen_width, 1);
- const int _y1 = y1;
-
- g_assert (gcwin32->pen_dashes);
-
- y1 = align_with_dash_offset (y1, gcwin32->pen_dashes, gcwin32->pen_num_dashes, gcwin32);
- for (n = 0; y1 < y2; n++)
- {
- int len = gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- if (y1 + len > y2)
- len = y2 - y1;
- if (n % 2 == 0 && y1 + len > _y1)
- if (!GDI_CALL (PatBlt, (gcwin32->hdc, x - pen_width / 2,
- y1 < _y1 ? _y1 : y1,
- pen_width, len,
- rop2_to_patblt_rop (gcwin32->rop2))))
- return FALSE;
-
- y1 += gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- }
-
- if (gcwin32->line_style == GDK_LINE_DOUBLE_DASH)
- {
- HBRUSH hbr;
-
- if ((hbr = SelectObject (gcwin32->hdc, gcwin32->pen_hbrbg)) == HGDI_ERROR)
- return FALSE;
- y1 = _y1;
- y1 += gcwin32->pen_dash_offset;
- for (n = 0; y1 < y2; n++)
- {
- int len = gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- if (y1 + len > y2)
- len = y2 - y1;
- if (n % 2)
- if (!GDI_CALL (PatBlt, (gcwin32->hdc, x - pen_width / 2, y1,
- pen_width, len,
- rop2_to_patblt_rop (gcwin32->rop2))))
- return FALSE;
-
- y1 += gcwin32->pen_dashes[n % gcwin32->pen_num_dashes];
- }
- if (SelectObject (gcwin32->hdc, hbr) == HGDI_ERROR)
- return FALSE;
- }
-
- return TRUE;
-}
-
-static cairo_region_t *
-widen_bounds (GdkRectangle *bounds,
- gint pen_width)
-{
- if (pen_width == 0)
- pen_width = 1;
-
- bounds->x -= pen_width;
- bounds->y -= pen_width;
- bounds->width += 2 * pen_width;
- bounds->height += 2 * pen_width;
-
- return cairo_region_create_rectangle (bounds);
-}
-
-static void
-blit_from_pixmap (gboolean use_fg_bg,
- GdkDrawableImplWin32 *dest,
- HDC hdc,
- GdkPixmapImplWin32 *src,
- GdkGC *gc,
- gint xsrc,
- gint ysrc,
- gint xdest,
- gint ydest,
- gint width,
- gint height)
-{
- GdkGCWin32 *gcwin32 = GDK_GC_WIN32 (gc);
- HDC srcdc;
- HBITMAP holdbitmap;
- RGBQUAD oldtable[256], newtable[256];
- COLORREF bg, fg;
-
- gint newtable_size = 0, oldtable_size = 0;
- gboolean ok = TRUE;
-
- GDK_NOTE (DRAW, g_print ("blit_from_pixmap\n"));
-
- srcdc = _gdk_win32_drawable_acquire_dc (GDK_DRAWABLE (src));
- if (!srcdc)
- return;
-
- if (!(holdbitmap = SelectObject (srcdc, ((GdkDrawableImplWin32 *) src)->handle)))
- WIN32_GDI_FAILED ("SelectObject");
- else
- {
- if (GDK_PIXMAP_OBJECT (src->parent_instance.wrapper)->depth <= 8)
- {
- /* Blitting from a 1, 4 or 8-bit pixmap */
-
- if ((oldtable_size = GetDIBColorTable (srcdc, 0, 256, oldtable)) == 0)
- WIN32_GDI_FAILED ("GetDIBColorTable");
- else if (GDK_PIXMAP_OBJECT (src->parent_instance.wrapper)->depth == 1)
- {
- /* Blitting from an 1-bit pixmap */
-
- gint bgix, fgix;
-
- if (use_fg_bg)
- {
- bgix = _gdk_gc_get_bg_pixel (gc);
- fgix = _gdk_gc_get_fg_pixel (gc);
- }
- else
- {
- bgix = 0;
- fgix = 1;
- }
-
- if (GDK_IS_PIXMAP_IMPL_WIN32 (dest) &&
- GDK_PIXMAP_OBJECT (dest->wrapper)->depth <= 8)
- {
- /* Destination is also pixmap, get fg and bg from
- * its palette. Either use the foreground and
- * background pixel values in the GC, or 0
- * and 1 to index the palette.
- */
- if (!GDI_CALL (GetDIBColorTable, (hdc, bgix, 1, newtable)) ||
- !GDI_CALL (GetDIBColorTable, (hdc, fgix, 1, newtable+1)))
- ok = FALSE;
- }
- else
- {
- /* Destination is a window, get fg and bg from its
- * colormap
- */
-
- bg = _gdk_win32_colormap_color (dest->colormap, bgix);
- fg = _gdk_win32_colormap_color (dest->colormap, fgix);
- newtable[0].rgbBlue = GetBValue (bg);
- newtable[0].rgbGreen = GetGValue (bg);
- newtable[0].rgbRed = GetRValue (bg);
- newtable[0].rgbReserved = 0;
- newtable[1].rgbBlue = GetBValue (fg);
- newtable[1].rgbGreen = GetGValue (fg);
- newtable[1].rgbRed = GetRValue (fg);
- newtable[1].rgbReserved = 0;
- }
- if (ok)
- GDK_NOTE (DRAW, g_print ("bg: %02x %02x %02x "
- "fg: %02x %02x %02x\n",
- newtable[0].rgbRed,
- newtable[0].rgbGreen,
- newtable[0].rgbBlue,
- newtable[1].rgbRed,
- newtable[1].rgbGreen,
- newtable[1].rgbBlue));
- newtable_size = 2;
- }
- else if (GDK_IS_PIXMAP_IMPL_WIN32 (dest))
- {
- /* Destination is pixmap, get its color table */
-
- if ((newtable_size = GetDIBColorTable (hdc, 0, 256, newtable)) == 0)
- WIN32_GDI_FAILED ("GetDIBColorTable"), ok = FALSE;
- }
-
- /* If blitting between pixmaps, set source's color table */
- if (ok && newtable_size > 0)
- {
- GDK_NOTE (MISC_OR_COLORMAP,
- g_print ("blit_from_pixmap: set color table"
- " hdc=%p count=%d\n",
- srcdc, newtable_size));
- if (!GDI_CALL (SetDIBColorTable, (srcdc, 0, newtable_size, newtable)))
- ok = FALSE;
- }
- }
-
- if (ok)
- if (!BitBlt (hdc, xdest, ydest, width, height,
- srcdc, xsrc, ysrc, rop2_to_rop3 (gcwin32->rop2)) &&
- GetLastError () != ERROR_INVALID_HANDLE)
- WIN32_GDI_FAILED ("BitBlt");
-
- /* Restore source's color table if necessary */
- if (ok && newtable_size > 0 && oldtable_size > 0)
- {
- GDK_NOTE (MISC_OR_COLORMAP,
- g_print ("blit_from_pixmap: reset color table"
- " hdc=%p count=%d\n",
- srcdc, oldtable_size));
- GDI_CALL (SetDIBColorTable, (srcdc, 0, oldtable_size, oldtable));
- }
-
- GDI_CALL (SelectObject, (srcdc, holdbitmap));
- }
-
- _gdk_win32_drawable_release_dc (GDK_DRAWABLE (src));
-}
-
-static void
-blit_inside_drawable (HDC hdc,
- GdkGCWin32 *gcwin32,
- gint xsrc,
- gint ysrc,
- gint xdest,
- gint ydest,
- gint width,
- gint height)
-
-{
- GDK_NOTE (DRAW, g_print ("blit_inside_drawable\n"));
-
- GDI_CALL (BitBlt, (hdc, xdest, ydest, width, height,
- hdc, xsrc, ysrc, rop2_to_rop3 (gcwin32->rop2)));
-}
-
-static void
-blit_from_window (HDC hdc,
- GdkGCWin32 *gcwin32,
- GdkDrawableImplWin32 *src,
- gint xsrc,
- gint ysrc,
- gint xdest,
- gint ydest,
- gint width,
- gint height)
-{
- HDC srcdc;
- HPALETTE holdpal = NULL;
- GdkColormap *cmap = gdk_colormap_get_system ();
-
- GDK_NOTE (DRAW, g_print ("blit_from_window\n"));
-
- if ((srcdc = GetDC (src->handle)) == NULL)
- {
- WIN32_GDI_FAILED ("GetDC");
- return;
- }
-
- if (cmap->visual->type == GDK_VISUAL_PSEUDO_COLOR ||
- cmap->visual->type == GDK_VISUAL_STATIC_COLOR)
- {
- gint k;
-
- if (!(holdpal = SelectPalette (srcdc, GDK_WIN32_COLORMAP_DATA (cmap)->hpal, FALSE)))
- WIN32_GDI_FAILED ("SelectPalette");
- else if ((k = RealizePalette (srcdc)) == GDI_ERROR)
- WIN32_GDI_FAILED ("RealizePalette");
- else if (k > 0)
- GDK_NOTE (MISC_OR_COLORMAP,
- g_print ("blit_from_window: realized %d\n", k));
- }
-
- GDI_CALL (BitBlt, (hdc, xdest, ydest, width, height,
- srcdc, xsrc, ysrc, rop2_to_rop3 (gcwin32->rop2)));
-
- if (holdpal != NULL)
- GDI_CALL (SelectPalette, (srcdc, holdpal, FALSE));
-
- GDI_CALL (ReleaseDC, (src->handle, srcdc));
-}
-
/**
* _gdk_win32_drawable_acquire_dc
* @drawable: a Win32 #GdkDrawable implementation
return GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->type_hint;
}
+static HRGN
+cairo_region_to_hrgn (const cairo_region_t *region,
+ gint x_origin,
+ gint y_origin)
+{
+ HRGN hrgn;
+ RGNDATA *rgndata;
+ RECT *rect;
+ cairo_rectangle_int_t r;
+ const int nrects = cairo_region_num_rectangles (region);
+ guint nbytes =
+ sizeof (RGNDATAHEADER) + (sizeof (RECT) * nrects);
+ int i;
+
+ rgndata = g_malloc (nbytes);
+ rgndata->rdh.dwSize = sizeof (RGNDATAHEADER);
+ rgndata->rdh.iType = RDH_RECTANGLES;
+ rgndata->rdh.nCount = rgndata->rdh.nRgnSize = 0;
+ SetRect (&rgndata->rdh.rcBound,
+ G_MAXLONG, G_MAXLONG, G_MINLONG, G_MINLONG);
+
+ for (i = 0; i < nrects; i++)
+ {
+ rect = ((RECT *) rgndata->Buffer) + rgndata->rdh.nCount++;
+
+ cairo_region_get_rectangle (region, i, &r);
+ rect->left = r.x + x_origin;
+ rect->right = rect->left + r.width;
+ rect->top = r.y + y_origin;
+ rect->bottom = rect->top + r.height;
+
+ if (rect->left < rgndata->rdh.rcBound.left)
+ rgndata->rdh.rcBound.left = rect->left;
+ if (rect->right > rgndata->rdh.rcBound.right)
+ rgndata->rdh.rcBound.right = rect->right;
+ if (rect->top < rgndata->rdh.rcBound.top)
+ rgndata->rdh.rcBound.top = rect->top;
+ if (rect->bottom > rgndata->rdh.rcBound.bottom)
+ rgndata->rdh.rcBound.bottom = rect->bottom;
+ }
+ if ((hrgn = ExtCreateRegion (NULL, nbytes, rgndata)) == NULL)
+ WIN32_API_FAILED ("ExtCreateRegion");
+
+ g_free (rgndata);
+
+ return (hrgn);
+}
+
static void
gdk_win32_window_shape_combine_region (GdkWindow *window,
const cairo_region_t *shape_region,
{
HRGN hrgn;
- hrgn = _gdk_win32_cairo_region_to_hrgn (shape_region, 0, 0);
+ hrgn = cairo_region_to_hrgn (shape_region, 0, 0);
GDK_NOTE (MISC, g_print ("gdk_win32_window_shape_combine_region: %p: %p\n",
GDK_WINDOW_HWND (window),
}
}
+/* This function originally from Jean-Edouard Lachand-Robert, and
+ * available at www.codeguru.com. Simplified for our needs, not sure
+ * how much of the original code left any longer. Now handles just
+ * one-bit deep bitmaps (in Window parlance, ie those that GDK calls
+ * bitmaps (and not pixmaps), with zero pixels being transparent.
+ */
+
+/* bitmap_to_hrgn : Create a region from the
+ * "non-transparent" pixels of a bitmap.
+ */
+
+static HRGN
+bitmap_to_hrgn (GdkPixmap *pixmap)
+{
+ HRGN hRgn = NULL;
+ HRGN h;
+ DWORD maxRects;
+ RGNDATA *pData;
+ guchar *bits;
+ gint width, height, bpl;
+ guchar *p;
+ gint x, y;
+
+ g_assert (GDK_PIXMAP_OBJECT(pixmap)->depth == 1);
+
+ bits = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl)->bits;
+ width = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl)->width;
+ height = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl)->height;
+ bpl = ((width - 1)/32 + 1)*4;
+
+ /* For better performances, we will use the ExtCreateRegion()
+ * function to create the region. This function take a RGNDATA
+ * structure on entry. We will add rectangles by amount of
+ * ALLOC_UNIT number in this structure.
+ */
+ #define ALLOC_UNIT 100
+ maxRects = ALLOC_UNIT;
+
+ pData = g_malloc (sizeof (RGNDATAHEADER) + (sizeof (RECT) * maxRects));
+ pData->rdh.dwSize = sizeof (RGNDATAHEADER);
+ pData->rdh.iType = RDH_RECTANGLES;
+ pData->rdh.nCount = pData->rdh.nRgnSize = 0;
+ SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
+
+ for (y = 0; y < height; y++)
+ {
+ /* Scan each bitmap row from left to right*/
+ p = (guchar *) bits + y * bpl;
+ for (x = 0; x < width; x++)
+ {
+ /* Search for a continuous range of "non transparent pixels"*/
+ gint x0 = x;
+ while (x < width)
+ {
+ if ((((p[x/8])>>(7-(x%8)))&1) == 0)
+ /* This pixel is "transparent"*/
+ break;
+ x++;
+ }
+
+ if (x > x0)
+ {
+ RECT *pr;
+ /* Add the pixels (x0, y) to (x, y+1) as a new rectangle
+ * in the region
+ */
+ if (pData->rdh.nCount >= maxRects)
+ {
+ maxRects += ALLOC_UNIT;
+ pData = g_realloc (pData, sizeof(RGNDATAHEADER)
+ + (sizeof(RECT) * maxRects));
+ }
+ pr = (RECT *) &pData->Buffer;
+ SetRect (&pr[pData->rdh.nCount], x0, y, x, y+1);
+ if (x0 < pData->rdh.rcBound.left)
+ pData->rdh.rcBound.left = x0;
+ if (y < pData->rdh.rcBound.top)
+ pData->rdh.rcBound.top = y;
+ if (x > pData->rdh.rcBound.right)
+ pData->rdh.rcBound.right = x;
+ if (y+1 > pData->rdh.rcBound.bottom)
+ pData->rdh.rcBound.bottom = y+1;
+ pData->rdh.nCount++;
+
+ /* On Windows98, ExtCreateRegion() may fail if the
+ * number of rectangles is too large (ie: >
+ * 4000). Therefore, we have to create the region by
+ * multiple steps.
+ */
+ if (pData->rdh.nCount == 2000)
+ {
+ HRGN h = ExtCreateRegion (NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
+ if (hRgn)
+ {
+ CombineRgn(hRgn, hRgn, h, RGN_OR);
+ DeleteObject(h);
+ }
+ else
+ hRgn = h;
+ pData->rdh.nCount = 0;
+ SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
+ }
+ }
+ }
+ }
+
+ /* Create or extend the region with the remaining rectangles*/
+ h = ExtCreateRegion (NULL, sizeof (RGNDATAHEADER)
+ + (sizeof (RECT) * maxRects), pData);
+ if (hRgn)
+ {
+ CombineRgn (hRgn, hRgn, h, RGN_OR);
+ DeleteObject (h);
+ }
+ else
+ hRgn = h;
+
+ /* Clean up*/
+ g_free (pData);
+
+ return hRgn;
+}
+
cairo_region_t *
_gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
{
cairo_region_t *region;
- HRGN hrgn = _gdk_win32_bitmap_to_hrgn (mask);
+ HRGN hrgn = bitmap_to_hrgn (mask);
region = _gdk_win32_hrgn_to_region (hrgn);
DeleteObject (hrgn);
_gdk_win32_window_queue_antiexpose (GdkWindow *window,
cairo_region_t *area)
{
- HRGN hrgn = _gdk_win32_cairo_region_to_hrgn (area, 0, 0);
+ HRGN hrgn = cairo_region_to_hrgn (area, 0, 0);
GDK_NOTE (EVENTS, g_print ("_gdk_windowing_window_queue_antiexpose: ValidateRgn %p %s\n",
GDK_WINDOW_HWND (window),
else if (ret != NULLREGION)
{
/* Get current updateregion, move any part of it that intersects area by dx,dy */
- HRGN update = _gdk_win32_cairo_region_to_hrgn (area, 0, 0);
+ HRGN update = cairo_region_to_hrgn (area, 0, 0);
ret = CombineRgn (update, hrgn, update, RGN_AND);
if (ret == ERROR)
WIN32_API_FAILED ("CombineRgn");
projects / ~andy / gtk / commitdiff