1 /* GDK - The GIMP Drawing Kit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
33 #include "gdkpixmap.h"
34 #include "gdkregion-generic.h"
35 #include "gdkinternals.h"
36 #include "gdkprivate-win32.h"
38 static void gdk_win32_gc_destroy (GdkGC *gc);
39 static void gdk_win32_gc_get_values (GdkGC *gc,
41 static void gdk_win32_gc_set_values (GdkGC *gc,
43 GdkGCValuesMask values_mask);
44 static void gdk_win32_gc_set_dashes (GdkGC *gc,
49 static GdkGCClass gdk_win32_gc_class = {
51 gdk_win32_gc_get_values,
52 gdk_win32_gc_set_values,
53 gdk_win32_gc_set_dashes
57 gdk_win32_gc_values_to_win32values (GdkGCValues *values,
61 GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
65 GDK_NOTE (MISC, g_print ("{"));
67 if (mask & GDK_GC_FOREGROUND)
69 data->foreground = values->foreground.pixel;
70 data->values_mask |= GDK_GC_FOREGROUND;
71 GDK_NOTE (MISC, (g_print ("fg=%.06x", data->foreground),
75 if (mask & GDK_GC_BACKGROUND)
77 data->background = values->background.pixel;
78 data->values_mask |= GDK_GC_BACKGROUND;
79 GDK_NOTE (MISC, (g_print ("%sbg=%.06x", s, data->background),
83 if ((mask & GDK_GC_FONT) && (values->font->type == GDK_FONT_FONT
84 || values->font->type == GDK_FONT_FONTSET))
86 if (data->font != NULL)
87 gdk_font_unref (data->font);
88 data->font = values->font;
89 if (data->font != NULL)
93 gdk_font_ref (data->font);
94 data->values_mask |= GDK_GC_FONT;
95 GDK_NOTE (MISC, (xlfd = gdk_font_full_name_get (data->font),
96 g_print ("%sfont=%s", s, xlfd),
98 gdk_font_full_name_free (xlfd)));
102 data->values_mask &= ~GDK_GC_FONT;
103 GDK_NOTE (MISC, (g_print ("%sfont=NULL"),
108 if (mask & GDK_GC_FUNCTION)
110 GDK_NOTE (MISC, (g_print ("%srop2=", s),
112 switch (values->function)
115 data->rop2 = R2_COPYPEN;
116 GDK_NOTE (MISC, g_print ("COPYPEN"));
120 GDK_NOTE (MISC, g_print ("NOT"));
123 data->rop2 = R2_XORPEN;
124 GDK_NOTE (MISC, g_print ("XORPEN"));
127 data->rop2 = R2_BLACK;
128 GDK_NOTE (MISC, g_print ("BLACK"));
131 data->rop2 = R2_MASKPEN;
132 GDK_NOTE (MISC, g_print ("MASKPEN"));
134 case GDK_AND_REVERSE:
135 data->rop2 = R2_MASKPENNOT;
136 GDK_NOTE (MISC, g_print ("MASKPENNOT"));
139 data->rop2 = R2_MASKNOTPEN;
140 GDK_NOTE (MISC, g_print ("MASKNOTPEN"));
144 GDK_NOTE (MISC, g_print ("NOP"));
147 data->rop2 = R2_MERGEPEN;
148 GDK_NOTE (MISC, g_print ("MERGEPEN"));
151 data->rop2 = R2_NOTXORPEN;
152 GDK_NOTE (MISC, g_print ("NOTXORPEN"));
155 data->rop2 = R2_MERGEPENNOT;
156 GDK_NOTE (MISC, g_print ("MERGEPENNOT"));
158 case GDK_COPY_INVERT:
159 data->rop2 = R2_NOTCOPYPEN;
160 GDK_NOTE (MISC, g_print ("NOTCOPYPEN"));
163 data->rop2 = R2_MERGENOTPEN;
164 GDK_NOTE (MISC, g_print ("MERGENOTPEN"));
167 data->rop2 = R2_NOTMASKPEN;
168 GDK_NOTE (MISC, g_print ("NOTMASKPEN"));
171 data->rop2 = R2_NOTMERGEPEN;
172 GDK_NOTE (MISC, g_print ("NOTMERGEPEN"));
175 data->rop2 = R2_WHITE;
176 GDK_NOTE (MISC, g_print ("WHITE"));
179 data->values_mask |= GDK_GC_FUNCTION;
182 if (mask & GDK_GC_FILL)
184 data->fill_style = values->fill;
185 data->values_mask |= GDK_GC_FILL;
186 GDK_NOTE (MISC, (g_print ("%sfill=%d", s, data->fill_style),
190 if (mask & GDK_GC_TILE)
192 if (data->tile != NULL)
193 gdk_drawable_unref (data->tile);
194 data->tile = values->tile;
195 if (data->tile != NULL)
197 gdk_drawable_ref (data->tile);
198 data->values_mask |= GDK_GC_TILE;
199 GDK_NOTE (MISC, (g_print ("%stile=%#x", s,
200 GDK_DRAWABLE_XID (data->tile)),
205 data->values_mask &= ~GDK_GC_TILE;
206 GDK_NOTE (MISC, (g_print ("%stile=NULL", s),
211 if (mask & GDK_GC_STIPPLE)
213 if (data->stipple != NULL)
214 gdk_drawable_unref (data->stipple);
215 data->stipple = values->stipple;
216 if (data->stipple != NULL)
218 gdk_drawable_get_size (data->stipple, &sw, &sh);
220 if (sw != 8 || sh != 8)
222 /* It seems that it *must* be 8x8, at least on my machine.
223 * Thus, tile an 8x8 bitmap with the stipple in case it is
224 * smaller, or simply use just the top left 8x8 in case it is
228 GdkPixmap *bm = gdk_bitmap_create_from_data (NULL, dummy, 8, 8);
229 GdkGC *gc = gdk_gc_new (bm);
238 gdk_draw_drawable (bm, gc, data->stipple, 0, 0, i, j, sw, sh);
247 gdk_drawable_ref (data->stipple);
248 data->values_mask |= GDK_GC_STIPPLE;
249 GDK_NOTE (MISC, (g_print ("%sstipple=%#x", s,
250 GDK_DRAWABLE_XID (data->stipple)),
255 data->values_mask &= ~GDK_GC_STIPPLE;
256 GDK_NOTE (MISC, (g_print ("%sstipple=NULL", s),
261 if (mask & GDK_GC_CLIP_MASK)
263 if (data->clip_region != NULL)
265 gdk_region_destroy (data->clip_region);
266 data->clip_region = NULL;
268 if (data->hcliprgn != NULL)
269 DeleteObject (data->hcliprgn);
271 if (values->clip_mask != NULL)
274 BitmapToRegion ((HBITMAP) GDK_DRAWABLE_XID (values->clip_mask));
275 data->values_mask |= GDK_GC_CLIP_MASK;
276 OffsetRgn (data->hcliprgn,
277 ((GdkGCPrivate *) gc)->clip_x_origin,
278 ((GdkGCPrivate *) gc)->clip_y_origin);
282 data->hcliprgn = NULL;
283 data->values_mask &= ~GDK_GC_CLIP_MASK;
285 GDK_NOTE (MISC, (g_print ("%sclip=%#x", s, data->hcliprgn),
289 if (mask & GDK_GC_SUBWINDOW)
291 data->subwindow_mode = values->subwindow_mode;
292 data->values_mask |= GDK_GC_SUBWINDOW;
293 GDK_NOTE (MISC, (g_print ("%ssubw=%d", s, data->subwindow_mode),
297 if (mask & GDK_GC_TS_X_ORIGIN)
299 data->values_mask |= GDK_GC_TS_X_ORIGIN;
300 GDK_NOTE (MISC, (g_print ("%sts_x=%d", s, values->ts_x_origin),
304 if (mask & GDK_GC_TS_Y_ORIGIN)
306 data->values_mask |= GDK_GC_TS_Y_ORIGIN;
307 GDK_NOTE (MISC, (g_print ("%sts_y=%d", s, values->ts_y_origin),
311 if (mask & GDK_GC_CLIP_X_ORIGIN)
313 data->values_mask |= GDK_GC_CLIP_X_ORIGIN;
314 GDK_NOTE (MISC, (g_print ("%sclip_x=%d", s, values->clip_x_origin),
318 if (mask & GDK_GC_CLIP_Y_ORIGIN)
320 data->values_mask |= GDK_GC_CLIP_Y_ORIGIN;
321 GDK_NOTE (MISC, (g_print ("%sclip_y=%d", s, values->clip_y_origin),
325 if (mask & GDK_GC_EXPOSURES)
327 data->graphics_exposures = values->graphics_exposures;
328 data->values_mask |= GDK_GC_EXPOSURES;
329 GDK_NOTE (MISC, (g_print ("%sexp=%d", s, data->graphics_exposures),
333 if (mask & GDK_GC_LINE_WIDTH)
335 data->pen_width = values->line_width;
336 data->values_mask |= GDK_GC_LINE_WIDTH;
337 GDK_NOTE (MISC, (g_print ("%spw=%d", s, data->pen_width),
341 if (mask & GDK_GC_LINE_STYLE)
343 data->pen_style &= ~(PS_STYLE_MASK);
344 GDK_NOTE (MISC, (g_print ("%sps|=", s),
346 switch (values->line_style)
349 GDK_NOTE (MISC, g_print ("LINE_SOLID"));
350 data->pen_style |= PS_SOLID;
352 case GDK_LINE_ON_OFF_DASH:
353 case GDK_LINE_DOUBLE_DASH: /* ??? */
354 GDK_NOTE (MISC, g_print ("DASH"));
355 data->pen_style |= PS_DASH;
358 data->values_mask |= GDK_GC_LINE_STYLE;
361 if (mask & GDK_GC_CAP_STYLE)
363 data->pen_style &= ~(PS_ENDCAP_MASK);
364 GDK_NOTE (MISC, (g_print ("%sps|=", s),
366 switch (values->cap_style)
368 case GDK_CAP_NOT_LAST: /* ??? */
370 GDK_NOTE (MISC, g_print ("ENDCAP_FLAT"));
371 data->pen_style |= PS_ENDCAP_FLAT;
374 GDK_NOTE (MISC, g_print ("ENDCAP_ROUND"));
375 data->pen_style |= PS_ENDCAP_ROUND;
377 case GDK_CAP_PROJECTING:
378 GDK_NOTE (MISC, g_print ("ENDCAP_SQUARE"));
379 data->pen_style |= PS_ENDCAP_SQUARE;
382 data->values_mask |= GDK_GC_CAP_STYLE;
385 if (mask & GDK_GC_JOIN_STYLE)
387 data->pen_style &= ~(PS_JOIN_MASK);
388 GDK_NOTE (MISC, (g_print ("%sps|=", s),
390 switch (values->join_style)
393 GDK_NOTE (MISC, g_print ("JOIN_MITER"));
394 data->pen_style |= PS_JOIN_MITER;
397 GDK_NOTE (MISC, g_print ("JOIN_ROUND"));
398 data->pen_style |= PS_JOIN_ROUND;
401 GDK_NOTE (MISC, g_print ("JOIN_BEVEL"));
402 data->pen_style |= PS_JOIN_BEVEL;
405 data->values_mask |= GDK_GC_JOIN_STYLE;
407 GDK_NOTE (MISC, g_print ("}\n"));
411 _gdk_win32_gc_new (GdkDrawable *drawable,
413 GdkGCValuesMask mask)
416 GdkGCPrivate *private;
417 GdkGCWin32Data *data;
419 gc = gdk_gc_alloc ();
420 private = (GdkGCPrivate *)gc;
422 private->klass = &gdk_win32_gc_class;
423 private->klass_data = data = g_new (GdkGCWin32Data, 1);
425 data->clip_region = NULL;
427 /* Use the same default values as X11 does, even if they don't make
428 * sense per se. But apps always set fg and bg anyway.
430 data->foreground = 0;
431 data->background = 1;
433 data->rop2 = R2_COPYPEN;
434 data->fill_style = GDK_SOLID;
436 data->stipple = NULL;
437 data->pen_style = PS_GEOMETRIC|PS_ENDCAP_FLAT|PS_JOIN_MITER;
440 data->values_mask = GDK_GC_FUNCTION | GDK_GC_FILL;
442 GDK_NOTE (MISC, g_print ("_gdk_win32_gc_new: "));
443 gdk_win32_gc_values_to_win32values (values, mask, gc);
447 data->hcliprgn = NULL;
449 GDK_NOTE (MISC, g_print (" = %p\n", gc));
455 gdk_win32_gc_destroy (GdkGC *gc)
457 GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
459 if (data->clip_region)
460 gdk_region_destroy (data->clip_region);
462 if (data->values_mask & GDK_GC_FONT)
463 gdk_font_unref (data->font);
465 if (data->values_mask & GDK_GC_TILE)
466 gdk_drawable_unref (data->tile);
468 if (data->values_mask & GDK_GC_STIPPLE)
469 gdk_drawable_unref (data->stipple);
471 g_free (GDK_GC_WIN32DATA (gc));
475 gdk_win32_gc_get_values (GdkGC *gc,
478 GdkGCPrivate *private = (GdkGCPrivate *) gc;
479 GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
481 values->foreground.pixel = data->foreground;
482 values->background.pixel = data->background;
483 values->font = data->font;
488 values->function = GDK_COPY; break;
490 values->function = GDK_INVERT; break;
492 values->function = GDK_XOR; break;
494 values->function = GDK_CLEAR; break;
496 values->function = GDK_AND; break;
498 values->function = GDK_AND_REVERSE; break;
500 values->function = GDK_AND_INVERT; break;
502 values->function = GDK_NOOP; break;
504 values->function = GDK_OR; break;
506 values->function = GDK_EQUIV; break;
508 values->function = GDK_OR_REVERSE; break;
510 values->function = GDK_COPY_INVERT; break;
512 values->function = GDK_OR_INVERT; break;
514 values->function = GDK_NAND; break;
516 values->function = GDK_NOR; break;
518 values->function = GDK_SET; break;
521 values->fill = data->fill_style;
523 values->tile = data->tile;
524 values->stipple = data->stipple;
526 /* Also the X11 backend always returns a NULL clip_mask */
527 values->clip_mask = NULL;
529 values->subwindow_mode = data->subwindow_mode;
530 values->ts_x_origin = private->ts_x_origin;
531 values->ts_y_origin = private->ts_y_origin;
532 values->clip_x_origin = private->clip_x_origin;
533 values->clip_y_origin = private->clip_y_origin;
534 values->graphics_exposures = data->graphics_exposures;
535 values->line_width = data->pen_width;
537 if (data->pen_style & PS_SOLID)
538 values->line_style = GDK_LINE_SOLID;
539 else if (data->pen_style & PS_DASH)
540 values->line_style = GDK_LINE_ON_OFF_DASH;
542 values->line_style = GDK_LINE_SOLID;
544 /* PS_ENDCAP_ROUND is zero */
545 if (data->pen_style & PS_ENDCAP_FLAT)
546 values->cap_style = GDK_CAP_BUTT;
547 else if (data->pen_style & PS_ENDCAP_SQUARE)
548 values->cap_style = GDK_CAP_PROJECTING;
550 values->cap_style = GDK_CAP_ROUND;
552 /* PS_JOIN_ROUND is zero */
553 if (data->pen_style & PS_JOIN_MITER)
554 values->join_style = GDK_JOIN_MITER;
555 else if (data->pen_style & PS_JOIN_BEVEL)
556 values->join_style = GDK_JOIN_BEVEL;
558 values->join_style = GDK_JOIN_ROUND;
562 gdk_win32_gc_set_values (GdkGC *gc,
564 GdkGCValuesMask mask)
566 GDK_NOTE (MISC, g_print ("gdk_win32_gc_set_values: "));
567 gdk_win32_gc_values_to_win32values (values, mask, gc);
571 gdk_win32_gc_set_dashes (GdkGC *gc,
576 GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
578 data->pen_style &= ~(PS_STYLE_MASK);
579 data->pen_style |= PS_DASH;
582 * Set the extended line style. This could be done by
583 * PS_USERSTYLE and ExtCreatePen; but ONLY on WinNT,
584 * so let's make a guess (based on the implementation
585 * in DIA). On Win9x this does only work for lines
588 * More workarounds for Win9x descibed at:
589 * http://www.codeguru.com/gdi/dashed.shtml
591 if (!IS_WIN_NT (windows_version) && data->pen_width > 1)
593 GDK_NOTE (MISC, g_print ("gdk_win32_gc_set_dashes: not fully supported\n"));
594 data->pen_style |= PS_SOLID;
598 /* data->pen_style = PS_COSMETIC; ??? */
601 if ((dash_list[0] == dash_list[1]) && (dash_list[0] > 2))
603 data->pen_style |= PS_DASH;
604 GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DASH (%d,%d)\n",
605 dash_list[0], dash_list[1]));
609 data->pen_style |= PS_DOT;
610 GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DOT (%d,%d)\n",
611 dash_list[0], dash_list[1]));
616 data->pen_style |= PS_DASHDOT;
617 GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DASHDOT (%d,%d,%d,%d)\n",
618 dash_list[0], dash_list[1],
619 dash_list[2], dash_list[3]));
623 data->pen_style |= PS_DASHDOTDOT;
624 GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DASHDOTDOT (%d,%d,%d,%d,%d,%d)\n",
625 dash_list[0], dash_list[1],
626 dash_list[2], dash_list[3],
627 dash_list[4], dash_list[5]));
631 data->pen_style |= PS_DASH;
632 GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: no guess for %d dashes\n", n));
637 gdk_gc_set_clip_rectangle (GdkGC *gc,
638 GdkRectangle *rectangle)
640 GdkGCWin32Data *data;
642 g_return_if_fail (gc != NULL);
644 data = GDK_GC_WIN32DATA (gc);
646 if (data->clip_region)
647 gdk_region_destroy (data->clip_region);
652 g_print ("gdk_gc_set_clip_rectangle: (%d) %dx%d@+%d+%d\n",
654 rectangle->width, rectangle->height,
655 rectangle->x, rectangle->y));
656 data->clip_region = gdk_region_rectangle (rectangle);
657 data->values_mask |= GDK_GC_CLIP_MASK;
661 GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_rectangle: (%d) NULL\n",
663 data->clip_region = NULL;
664 data->values_mask &= ~GDK_GC_CLIP_MASK;
666 data->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
670 gdk_gc_set_clip_region (GdkGC *gc,
673 GdkGCPrivate *private = (GdkGCPrivate *) gc;
674 GdkGCWin32Data *data;
676 g_return_if_fail (gc != NULL);
678 data = GDK_GC_WIN32DATA (gc);
680 if (data->clip_region)
681 gdk_region_destroy (data->clip_region);
685 GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_region: %d %dx%d+%d+%d\n",
687 region->extents.x2 - region->extents.x1,
688 region->extents.y2 - region->extents.y1,
689 region->extents.x1, region->extents.y1));
690 data->clip_region = gdk_region_copy (region);
691 data->values_mask |= GDK_GC_CLIP_MASK;
695 GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_region: %d NULL\n",
697 data->clip_region = NULL;
698 data->values_mask &= ~GDK_GC_CLIP_MASK;
701 private->clip_x_origin = 0;
702 private->clip_y_origin = 0;
704 data->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
708 gdk_gc_copy (GdkGC *dst_gc, GdkGC *src_gc)
710 GdkGCWin32Data *dst_data = GDK_GC_WIN32DATA (dst_gc);
711 GdkGCWin32Data *src_data = GDK_GC_WIN32DATA (src_gc);
715 if (dst_data->font != NULL)
716 gdk_font_unref (dst_data->font);
717 if (dst_data->tile != NULL)
718 gdk_drawable_unref (dst_data->tile);
719 if (dst_data->stipple != NULL)
720 gdk_drawable_unref (dst_data->stipple);
721 if (dst_data->clip_region != NULL)
722 gdk_region_destroy (dst_data->clip_region);
724 *dst_data = *src_data;
726 if (dst_data->clip_region != NULL)
727 dst_data->clip_region = gdk_region_copy (dst_data->clip_region);
728 if (dst_data->font != NULL)
729 gdk_font_ref (dst_data->font);
730 if (dst_data->tile != NULL)
731 gdk_drawable_ref (dst_data->tile);
732 if (dst_data->stipple != NULL)
733 gdk_drawable_ref (dst_data->stipple);
736 static guint bitmask[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
739 gdk_colormap_color (GdkColormapPrivateWin32 *colormap_private,
745 if (colormap_private == NULL || colormap_private->xcolormap->rc_palette)
746 return PALETTEINDEX (pixel);
749 visual = colormap_private->base.visual;
750 r = (pixel & visual->red_mask) >> visual->red_shift;
751 r = (r * 255) / bitmask[visual->red_prec];
752 g = (pixel & visual->green_mask) >> visual->green_shift;
753 g = (g * 255) / bitmask[visual->green_prec];
754 b = (pixel & visual->blue_mask) >> visual->blue_shift;
755 b = (b * 255) / bitmask[visual->blue_prec];
757 return RGB (r, g, b);
762 predraw_set_foreground (GdkGCPrivate *gc_private,
763 GdkColormapPrivateWin32 *colormap_private,
770 GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
772 if (colormap_private == NULL)
774 /* A 1 bit deep bitmap */
779 PALETTEENTRY palPalEntry[2];
781 static HPALETTE hpal = NULL;
785 /* Create a b&w palette */
786 logpal.palVersion = 0x300;
787 logpal.palNumEntries = 2;
788 logpal.palPalEntry[0].peRed =
789 logpal.palPalEntry[0].peGreen =
790 logpal.palPalEntry[0].peBlue = 0x00;
791 logpal.palPalEntry[0].peFlags = 0x00;
792 logpal.palPalEntry[1].peRed =
793 logpal.palPalEntry[1].peGreen =
794 logpal.palPalEntry[1].peBlue = 0xFF;
795 logpal.palPalEntry[1].peFlags = 0x00;
796 if ((hpal = CreatePalette ((LOGPALETTE *) &logpal)) == NULL)
797 WIN32_GDI_FAILED ("CreatePalette"), *ok = FALSE;
799 SelectPalette (data->xgc, hpal, FALSE);
800 RealizePalette (data->xgc);
801 fg = PALETTEINDEX (data->foreground);
803 else if (colormap_private->xcolormap->rc_palette)
806 if (SelectPalette (data->xgc, colormap_private->xcolormap->palette,
808 WIN32_GDI_FAILED ("SelectPalette"), *ok = FALSE;
809 if (TRUE || colormap_private->xcolormap->stale)
811 if ((k = RealizePalette (data->xgc)) == GDI_ERROR)
812 WIN32_GDI_FAILED ("RealizePalette"), *ok = FALSE;
813 colormap_private->xcolormap->stale = FALSE;
816 g_print ("Selected palette %#x for gc %#x, realized %d colors\n",
817 colormap_private->xcolormap->palette, data->xgc, k);
821 fg = gdk_colormap_color (colormap_private, data->foreground);
823 if (SetTextColor (data->xgc, fg) == CLR_INVALID)
824 WIN32_GDI_FAILED ("SetTextColor"), *ok = FALSE;
826 /* Create and select pen and brush. */
828 logbrush.lbStyle = BS_SOLID;
829 logbrush.lbColor = fg;
831 if (*ok && (hpen = ExtCreatePen (data->pen_style,
832 (data->pen_width > 0 ? data->pen_width : 1),
833 &logbrush, 0, NULL)) == NULL)
834 WIN32_GDI_FAILED ("ExtCreatePen");
836 if (SelectObject (data->xgc, hpen) == NULL)
837 WIN32_GDI_FAILED ("SelectObject"), *ok = FALSE;
839 switch (data->fill_style)
841 case GDK_OPAQUE_STIPPLED:
842 if (*ok && (hbr = CreatePatternBrush (GDK_DRAWABLE_XID (data->stipple))) == NULL)
843 WIN32_GDI_FAILED ("CreatePatternBrush"), *ok = FALSE;
845 if (*ok && !SetBrushOrgEx(data->xgc, gc_private->ts_x_origin,
846 gc_private->ts_y_origin, NULL))
847 WIN32_GDI_FAILED ("SetBrushOrgEx"), *ok = FALSE;
852 if (*ok && (hbr = CreateSolidBrush (fg)) == NULL)
853 WIN32_GDI_FAILED ("CreateSolidBrush"), *ok = FALSE;
856 if (*ok && SelectObject (data->xgc, hbr) == NULL)
857 WIN32_GDI_FAILED ("SelectObject"), *ok = FALSE;
861 predraw_set_background (GdkGCWin32Data *data,
862 GdkColormapPrivateWin32 *colormap_private,
865 COLORREF bg = gdk_colormap_color (colormap_private, data->background);
867 if (SetBkColor (data->xgc, bg) == CLR_INVALID)
868 WIN32_GDI_FAILED ("SetBkColor"), *ok = FALSE;
872 gdk_gc_predraw (GdkDrawable *drawable,
873 GdkGCPrivate *gc_private,
874 GdkGCValuesMask usage)
876 GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
877 GdkColormapPrivateWin32 *colormap_private =
878 (GdkColormapPrivateWin32 *) drawable_private->colormap;
879 GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
883 g_assert (data->xgc == NULL);
885 data->hwnd = GDK_DRAWABLE_XID (drawable);
887 if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
889 if ((data->xgc = CreateCompatibleDC (NULL)) == NULL)
890 WIN32_GDI_FAILED ("CreateCompatibleDC"), ok = FALSE;
892 if (ok && (data->saved_dc = SaveDC (data->xgc)) == 0)
893 WIN32_GDI_FAILED ("SaveDC"), ok = FALSE;
895 if (ok && SelectObject (data->xgc, data->hwnd) == NULL)
896 WIN32_GDI_FAILED ("SelectObject"), ok = FALSE;
900 if ((data->xgc = GetDC (data->hwnd)) == NULL)
901 WIN32_GDI_FAILED ("GetDC");
903 if (ok && (data->saved_dc = SaveDC (data->xgc)) == 0)
904 WIN32_GDI_FAILED ("SaveDC");
907 if (ok && (usage & GDK_GC_FOREGROUND))
908 predraw_set_foreground (gc_private, colormap_private, &ok);
911 && (usage & GDK_GC_BACKGROUND)
912 && (data->values_mask & GDK_GC_BACKGROUND))
913 predraw_set_background (data, colormap_private, &ok);
915 if (ok && (usage & GDK_GC_FONT))
917 if (SetBkMode (data->xgc, TRANSPARENT) == 0)
918 WIN32_GDI_FAILED ("SetBkMode"), ok = FALSE;
920 if (ok && SetTextAlign (data->xgc, TA_BASELINE) == GDI_ERROR)
921 WIN32_GDI_FAILED ("SetTextAlign"), ok = FALSE;
924 if (ok && (data->values_mask & GDK_GC_FUNCTION))
925 if (SetROP2 (data->xgc, data->rop2) == 0)
926 WIN32_GDI_FAILED ("SetROP2"), ok = FALSE;
928 if (data->values_mask & GDK_GC_CLIP_MASK)
929 g_assert ((data->clip_region != NULL) != (data->hcliprgn != NULL));
932 && (data->values_mask & GDK_GC_CLIP_MASK)
933 && data->clip_region != NULL)
938 GdkRegionBox *boxes = data->clip_region->rects;
940 sizeof (RGNDATAHEADER) + (sizeof (RECT) * data->clip_region->numRects);
943 rgndata = g_malloc (nbytes);
944 rgndata->rdh.dwSize = sizeof (RGNDATAHEADER);
945 rgndata->rdh.iType = RDH_RECTANGLES;
946 rgndata->rdh.nCount = rgndata->rdh.nRgnSize = 0;
947 SetRect (&rgndata->rdh.rcBound,
948 G_MAXSHORT, G_MAXSHORT, G_MINSHORT, G_MINSHORT);
950 for (i = 0; i < data->clip_region->numRects; i++)
952 rect = ((RECT *) rgndata->Buffer) + rgndata->rdh.nCount++;
954 rect->left = CLAMP (boxes[i].x1 + gc_private->clip_x_origin,
955 G_MINSHORT, G_MAXSHORT);
956 rect->right = CLAMP (boxes[i].x2 + gc_private->clip_x_origin,
957 G_MINSHORT, G_MAXSHORT);
958 rect->top = CLAMP (boxes[i].y1 + gc_private->clip_y_origin,
959 G_MINSHORT, G_MAXSHORT);
960 rect->bottom = CLAMP (boxes[i].y2 + gc_private->clip_y_origin,
961 G_MINSHORT, G_MAXSHORT);
963 GDK_NOTE (MISC, g_print ("clip rgn box %d: %dx%d@+%d+%d\n",
965 rect->right-rect->left,
966 rect->bottom-rect->top,
967 rect->left, rect->top));
969 if (rect->left < rgndata->rdh.rcBound.left)
970 rgndata->rdh.rcBound.left = rect->left;
971 if (rect->right > rgndata->rdh.rcBound.right)
972 rgndata->rdh.rcBound.right = rect->right;
973 if (rect->top < rgndata->rdh.rcBound.top)
974 rgndata->rdh.rcBound.top = rect->top;
975 if (rect->bottom > rgndata->rdh.rcBound.bottom)
976 rgndata->rdh.rcBound.bottom = rect->bottom;
978 if ((hrgn = ExtCreateRegion (NULL, nbytes, rgndata)) == NULL)
979 WIN32_API_FAILED ("ExtCreateRegion"), ok = FALSE;
981 if (ok && SelectClipRgn (data->xgc, hrgn) == ERROR)
982 WIN32_API_FAILED ("SelectClipRgn"), ok = FALSE;
988 && (data->values_mask & GDK_GC_CLIP_MASK)
989 && data->hcliprgn != NULL)
991 if (SelectClipRgn (data->xgc, data->hcliprgn) == ERROR)
992 WIN32_API_FAILED ("SelectClipRgn"), ok = FALSE;
995 if (gdk_debug_flags & GDK_DEBUG_MISC)
1003 g_print ("gdk_gc_predraw: %d: %#x\n", data, data->xgc);
1004 obj = GetCurrentObject (data->xgc, OBJ_BRUSH);
1005 GetObject (obj, sizeof (LOGBRUSH), &logbrush);
1006 g_print ("brush: style: %s color: %.06x hatch: %#x\n",
1007 (logbrush.lbStyle == BS_HOLLOW ? "HOLLOW" :
1008 (logbrush.lbStyle == BS_PATTERN ? "PATTERN" :
1009 (logbrush.lbStyle == BS_SOLID ? "SOLID" :
1013 obj = GetCurrentObject (data->xgc, OBJ_PEN);
1014 GetObject (obj, sizeof (EXTLOGPEN), &extlogpen);
1015 g_print ("pen: type: %s style: %s endcap: %s join: %s width: %d brush: %s\n",
1016 ((extlogpen.elpPenStyle & PS_TYPE_MASK) ==
1017 PS_GEOMETRIC ? "GEOMETRIC" : "COSMETIC"),
1018 ((extlogpen.elpPenStyle & PS_STYLE_MASK) ==
1020 ((extlogpen.elpPenStyle & PS_STYLE_MASK) ==
1021 PS_SOLID ? "SOLID" : "???")),
1022 ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) ==
1023 PS_ENDCAP_FLAT ? "FLAT" :
1024 ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) ==
1025 PS_ENDCAP_ROUND ? "ROUND" :
1026 ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) ==
1027 PS_ENDCAP_SQUARE ? "ROUND" :
1028 ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) ==
1029 PS_ENDCAP_SQUARE ? "ROUND" : "???")))),
1030 ((extlogpen.elpPenStyle & PS_JOIN_MASK) ==
1031 PS_JOIN_BEVEL ? "BEVEL" :
1032 ((extlogpen.elpPenStyle & PS_JOIN_MASK) ==
1033 PS_JOIN_MITER ? "MITER" :
1034 ((extlogpen.elpPenStyle & PS_JOIN_MASK) ==
1035 PS_JOIN_ROUND ? "ROUND" : "???"))),
1037 (extlogpen.elpBrushStyle == BS_DIBPATTERN ? "DIBPATTERN" :
1038 (extlogpen.elpBrushStyle == BS_DIBPATTERNPT ? "DIBPATTERNPT" :
1039 (extlogpen.elpBrushStyle == BS_HATCHED ? "HATCHED" :
1040 (extlogpen.elpBrushStyle == BS_HOLLOW ? "HOLLOW" :
1041 (extlogpen.elpBrushStyle == BS_PATTERN ? "PATTERN" :
1042 (extlogpen.elpBrushStyle == BS_SOLID ? "SOLID" : "???")))))));
1043 hrgn = CreateRectRgn (0, 0, 0, 0);
1044 if ((flag = GetClipRgn (data->xgc, hrgn)) == -1)
1045 WIN32_API_FAILED ("GetClipRgn");
1047 g_print ("no clip region\n");
1050 GetRgnBox (hrgn, &rect);
1051 g_print ("clip region bbox: %dx%d@+%d+%d\n",
1052 rect.right - rect.left,
1053 rect.bottom - rect.top,
1054 rect.left, rect.top);
1062 gdk_gc_postdraw (GdkDrawable *drawable,
1063 GdkGCPrivate *gc_private,
1064 GdkGCValuesMask usage)
1066 GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
1067 GdkColormapPrivateWin32 *colormap_private =
1068 (GdkColormapPrivateWin32 *) drawable_private->colormap;
1069 GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
1070 HGDIOBJ hpen = NULL;
1073 if (usage & GDK_GC_FOREGROUND)
1075 if ((hpen = GetCurrentObject (data->xgc, OBJ_PEN)) == NULL)
1076 WIN32_GDI_FAILED ("GetCurrentObject");
1078 if ((hbr = GetCurrentObject (data->xgc, OBJ_BRUSH)) == NULL)
1079 WIN32_GDI_FAILED ("GetCurrentObject");
1082 if (!RestoreDC (data->xgc, data->saved_dc))
1083 WIN32_GDI_FAILED ("RestoreDC");
1085 if (colormap_private != NULL
1086 && colormap_private->xcolormap->rc_palette
1087 && colormap_private->xcolormap->stale)
1089 SelectPalette (data->xgc, GetStockObject (DEFAULT_PALETTE), FALSE);
1090 if (!UnrealizeObject (colormap_private->xcolormap->palette))
1091 WIN32_GDI_FAILED ("UnrealizeObject");
1094 if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
1096 if (!DeleteDC (data->xgc))
1097 WIN32_GDI_FAILED ("DeleteDC");
1101 ReleaseDC (data->hwnd, data->xgc);
1105 if (!DeleteObject (hpen))
1106 WIN32_GDI_FAILED ("DeleteObject");
1109 if (!DeleteObject (hbr))
1110 WIN32_GDI_FAILED ("DeleteObject");
1116 gdk_win32_hdc_get (GdkDrawable *drawable,
1118 GdkGCValuesMask usage)
1120 return gdk_gc_predraw (drawable, (GdkGCPrivate *) gc, usage);
1124 gdk_win32_hdc_release (GdkDrawable *drawable,
1126 GdkGCValuesMask usage)
1128 gdk_gc_postdraw (drawable, (GdkGCPrivate *) gc, usage);
1131 /* This function originally from Jean-Edouard Lachand-Robert, and
1132 * available at www.codeguru.com. Simplified for our needs, now
1133 * handles just one-bit deep bitmaps (in Window parlance, ie those
1134 * that GDK calls bitmaps (and not pixmaps), with zero pixels being
1139 * BitmapToRegion : Create a region from the "non-transparent" pixels of
1141 * Author : Jean-Edouard Lachand-Robert
1142 * (http://www.geocities.com/Paris/LeftBank/1160/resume.htm), June 1998.
1146 BitmapToRegion (HBITMAP hBmp)
1154 BITMAPINFOHEADER bmiHeader;
1158 RGBQUAD bmiColors[2];
1167 PALETTEENTRY palPalEntry[2];
1169 static HPALETTE bwPalette = NULL;
1182 /* Create a B&W palette */
1183 if (bwPalette == NULL)
1185 /* Create a b&w palette */
1186 logpal.palVersion = 0x300;
1187 logpal.palNumEntries = 2;
1188 logpal.palPalEntry[0].peRed =
1189 logpal.palPalEntry[0].peGreen =
1190 logpal.palPalEntry[0].peBlue = 0;
1191 logpal.palPalEntry[0].peFlags = 0;
1192 logpal.palPalEntry[1].peRed =
1193 logpal.palPalEntry[1].peGreen =
1194 logpal.palPalEntry[1].peBlue = 0xFF;
1195 logpal.palPalEntry[1].peFlags = 0;
1196 if ((bwPalette = CreatePalette ((LOGPALETTE *) &logpal)) == NULL)
1197 WIN32_GDI_FAILED ("CreatePalette");
1200 /* Create a memory DC inside which we will scan the bitmap content */
1201 hMemDC = CreateCompatibleDC (NULL);
1204 WIN32_GDI_FAILED ("CreateCompatibleDC");
1208 SelectPalette (hMemDC, bwPalette, FALSE);
1209 RealizePalette (hMemDC);
1211 /* Get bitmap size */
1212 GetObject(hBmp, sizeof(bm), &bm);
1214 /* Create a 8 bits depth bitmap and select it into the memory DC */
1215 bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
1216 bmi.bmiHeader.biWidth = bm.bmWidth;
1217 bmi.bmiHeader.biHeight = bm.bmHeight;
1218 bmi.bmiHeader.biPlanes = 1;
1219 bmi.bmiHeader.biBitCount = 8;
1220 bmi.bmiHeader.biCompression = BI_RGB;
1221 bmi.bmiHeader.biSizeImage = 0;
1222 bmi.bmiHeader.biXPelsPerMeter = 0;
1223 bmi.bmiHeader.biYPelsPerMeter = 0;
1224 bmi.bmiHeader.biClrUsed = 2;
1225 bmi.bmiHeader.biClrImportant = 2;
1227 bmi.bmiColors[0] = 0;
1228 bmi.bmiColors[1] = 1;
1229 hbm8 = CreateDIBSection (hMemDC, (BITMAPINFO *)&bmi,
1230 DIB_PAL_COLORS, &pbits8, NULL, 0);
1232 bmi.bmiColors[0].rgbBlue =
1233 bmi.bmiColors[0].rgbGreen =
1234 bmi.bmiColors[0].rgbRed = 0x00;
1235 bmi.bmiColors[0].rgbReserved = 0x00;
1237 bmi.bmiColors[1].rgbBlue =
1238 bmi.bmiColors[1].rgbGreen =
1239 bmi.bmiColors[1].rgbRed = 0xFF;
1240 bmi.bmiColors[0].rgbReserved = 0x00;
1242 hbm8 = CreateDIBSection (hMemDC, (BITMAPINFO *)&bmi,
1243 DIB_RGB_COLORS, &pbits8, NULL, 0);
1247 WIN32_GDI_FAILED ("CreateDIBSection");
1252 holdBmp = (HBITMAP) SelectObject (hMemDC, hbm8);
1254 /* Create a DC just to copy the bitmap into the memory DC*/
1255 hDC = CreateCompatibleDC (hMemDC);
1258 WIN32_GDI_FAILED ("CreateCompatibleDC");
1259 SelectObject (hMemDC, holdBmp);
1260 DeleteObject (hbm8);
1265 /* Get how many bytes per row we have for the bitmap bits */
1266 GetObject (hbm8, sizeof (bm8), &bm8);
1268 /* Hans Breuer found a fix to the long-standing erroneous behaviour
1269 * on NT 4.0: There seems to be a bug in Win NT 4.0 GDI: scanlines
1270 * in bitmaps are dword aligned on both Win95 and NT. In the case of
1271 * a bitmap with 22 bytes worth of width, GetObject above returns
1272 * with bmWidth == 22. On Win95 bmWidthBytes == 24, as it should be,
1273 * but on NT is it 22. We need to correct this here.
1275 bm8.bmWidthBytes = (((bm8.bmWidthBytes-1)/4)+1)*4; /* dword aligned!! */
1277 /* Copy the bitmap into the memory DC*/
1278 holdBmp2 = (HBITMAP) SelectObject (hDC, hBmp);
1280 if (!BitBlt (hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY))
1282 WIN32_GDI_FAILED ("BitBlt");
1283 SelectObject (hDC, holdBmp2);
1284 SelectObject (hMemDC, holdBmp);
1285 DeleteObject (hbm8);
1289 SelectObject (hDC, holdBmp2);
1292 /* For better performances, we will use the ExtCreateRegion()
1293 * function to create the region. This function take a RGNDATA
1294 * structure on entry. We will add rectangles by amount of
1295 * ALLOC_UNIT number in this structure.
1297 #define ALLOC_UNIT 100
1298 maxRects = ALLOC_UNIT;
1300 pData = g_malloc (sizeof (RGNDATAHEADER) + (sizeof (RECT) * maxRects));
1301 pData->rdh.dwSize = sizeof (RGNDATAHEADER);
1302 pData->rdh.iType = RDH_RECTANGLES;
1303 pData->rdh.nCount = pData->rdh.nRgnSize = 0;
1304 SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1306 /* Scan each bitmap from bottom to top (the bitmap is inverted vertically)*/
1307 p8 = (BYTE *) pbits8 + (bm8.bmHeight - 1) * bm8.bmWidthBytes;
1308 for (y = 0; y < bm.bmHeight; y++)
1310 /* Scan each bitmap row from left to right*/
1311 for (x = 0; x < bm.bmWidth; x++)
1313 /* Search for a continuous range of "non transparent pixels"*/
1316 while (x < bm.bmWidth)
1319 /* This pixel is "transparent"*/
1328 /* Add the pixels (x0, y) to (x, y+1) as a new rectangle
1331 if (pData->rdh.nCount >= maxRects)
1333 maxRects += ALLOC_UNIT;
1334 pData = g_realloc (pData, sizeof(RGNDATAHEADER)
1335 + (sizeof(RECT) * maxRects));
1337 pr = (RECT *) &pData->Buffer;
1338 SetRect (&pr[pData->rdh.nCount], x0, y, x, y+1);
1339 if (x0 < pData->rdh.rcBound.left)
1340 pData->rdh.rcBound.left = x0;
1341 if (y < pData->rdh.rcBound.top)
1342 pData->rdh.rcBound.top = y;
1343 if (x > pData->rdh.rcBound.right)
1344 pData->rdh.rcBound.right = x;
1345 if (y+1 > pData->rdh.rcBound.bottom)
1346 pData->rdh.rcBound.bottom = y+1;
1347 pData->rdh.nCount++;
1349 /* On Windows98, ExtCreateRegion() may fail if the
1350 * number of rectangles is too large (ie: >
1351 * 4000). Therefore, we have to create the region by
1354 if (pData->rdh.nCount == 2000)
1356 HRGN h = ExtCreateRegion (NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
1359 CombineRgn(hRgn, hRgn, h, RGN_OR);
1364 pData->rdh.nCount = 0;
1365 SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1370 /* Go to next row (remember, the bitmap is inverted vertically)*/
1371 p8 -= bm8.bmWidthBytes;
1374 /* Create or extend the region with the remaining rectangles*/
1375 h = ExtCreateRegion (NULL, sizeof (RGNDATAHEADER)
1376 + (sizeof (RECT) * maxRects), pData);
1379 CombineRgn (hRgn, hRgn, h, RGN_OR);
1386 SelectObject(hMemDC, holdBmp);
1387 DeleteObject (hbm8);