Pileus Git - ~andy/gtk/blob - gdk/win32/gdkgc-win32.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * Copyright (C) 1998-2004 Tor Lillqvist
   4  * Copyright (C) 2000-2004 Hans Breuer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /*
  23  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  24  * file for a list of people on the GTK+ Team.  See the ChangeLog
  25  * files for a list of changes.  These files are distributed with
  26  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  27  */
  28
  29 #define LINE_ATTRIBUTES (GDK_GC_LINE_WIDTH|GDK_GC_LINE_STYLE| \
  30                          GDK_GC_CAP_STYLE|GDK_GC_JOIN_STYLE)
  31
  32 #include "config.h"
  33 #include <string.h>
  34
  35 #include "gdkgc.h"
  36 #include "gdkfont.h"
  37 #include "gdkpixmap.h"
  38 #include "gdkregion-generic.h"
  39 #include "gdkprivate-win32.h"
  40
  41 static void gdk_win32_gc_get_values (GdkGC           *gc,
  42                                      GdkGCValues     *values);
  43 static void gdk_win32_gc_set_values (GdkGC           *gc,
  44                                      GdkGCValues     *values,
  45                                      GdkGCValuesMask  values_mask);
  46 static void gdk_win32_gc_set_dashes (GdkGC           *gc,
  47                                      gint             dash_offset,
  48                                      gint8            dash_list[],
  49                                      gint             n);
  50
  51 static void gdk_gc_win32_class_init (GdkGCWin32Class *klass);
  52 static void gdk_gc_win32_finalize   (GObject         *object);
  53
  54 static gpointer parent_class = NULL;
  55
  56 GType
  57 _gdk_gc_win32_get_type (void)
  58 {
  59   static GType object_type = 0;
  60
  61   if (!object_type)
  62     {
  63       static const GTypeInfo object_info =
  64       {
  65         sizeof (GdkGCWin32Class),
  66         (GBaseInitFunc) NULL,
  67         (GBaseFinalizeFunc) NULL,
  68         (GClassInitFunc) gdk_gc_win32_class_init,
  69         NULL,           /* class_finalize */
  70         NULL,           /* class_data */
  71         sizeof (GdkGCWin32),
  72         0,              /* n_preallocs */
  73         (GInstanceInitFunc) NULL,
  74       };
  75
  76       object_type = g_type_register_static (GDK_TYPE_GC,
  77                                             "GdkGCWin32",
  78                                             &object_info, 0);
  79     }
  80
  81   return object_type;
  82 }
  83
  84 static void
  85 gdk_gc_win32_class_init (GdkGCWin32Class *klass)
  86 {
  87   GObjectClass *object_class = G_OBJECT_CLASS (klass);
  88   GdkGCClass *gc_class = GDK_GC_CLASS (klass);
  89
  90   parent_class = g_type_class_peek_parent (klass);
  91
  92   object_class->finalize = gdk_gc_win32_finalize;
  93
  94   gc_class->get_values = gdk_win32_gc_get_values;
  95   gc_class->set_values = gdk_win32_gc_set_values;
  96   gc_class->set_dashes = gdk_win32_gc_set_dashes;
  97 }
  98
  99 static void
 100 gdk_gc_win32_finalize (GObject *object)
 101 {
 102   GdkGCWin32 *win32_gc = GDK_GC_WIN32 (object);
 103
 104   if (win32_gc->hcliprgn != NULL)
 105     DeleteObject (win32_gc->hcliprgn);
 106
 107   if (win32_gc->values_mask & GDK_GC_FONT)
 108     gdk_font_unref (win32_gc->font);
 109
 110   g_free (win32_gc->pen_dashes);
 111
 112   G_OBJECT_CLASS (parent_class)->finalize (object);
 113 }
 114
 115 static void
 116 fixup_pen (GdkGCWin32 *win32_gc)
 117 {
 118   win32_gc->pen_style = 0;
 119
 120   /* First look at GDK width and end cap style, set GDI pen type and
 121    * end cap.
 122    */
 123   if (win32_gc->pen_width == 0 &&
 124       win32_gc->cap_style == GDK_CAP_NOT_LAST)
 125     {
 126       /* Use a cosmetic pen, always width 1 */
 127       win32_gc->pen_style |= PS_COSMETIC;
 128     }
 129   else if (win32_gc->pen_width <= 1 &&
 130            win32_gc->cap_style == GDK_CAP_BUTT)
 131     {
 132       /* For 1 pixel wide lines PS_ENDCAP_ROUND means draw both ends,
 133        * even for one pixel length lines. But if we are drawing dashed
 134        * lines we can't use PS_ENDCAP_ROUND.
 135        */
 136       if (win32_gc->line_style == GDK_LINE_SOLID)
 137         win32_gc->pen_style |= PS_GEOMETRIC | PS_ENDCAP_ROUND;
 138       else
 139         win32_gc->pen_style |= PS_GEOMETRIC | PS_ENDCAP_FLAT;
 140     }
 141   else
 142     {
 143       win32_gc->pen_style |= PS_GEOMETRIC;
 144       switch (win32_gc->cap_style)
 145         {
 146         /* For non-zero-width lines X11's CapNotLast works like CapButt */
 147         case GDK_CAP_NOT_LAST:
 148         case GDK_CAP_BUTT:
 149           win32_gc->pen_style |= PS_ENDCAP_FLAT;
 150           break;
 151         case GDK_CAP_ROUND:
 152           win32_gc->pen_style |= PS_ENDCAP_ROUND;
 153           break;
 154         case GDK_CAP_PROJECTING:
 155           win32_gc->pen_style |= PS_ENDCAP_SQUARE;
 156           break;
 157         }
 158     }
 159
 160   /* Next look at GDK line style, set GDI pen style attribute */
 161   switch (win32_gc->line_style)
 162     {
 163     case GDK_LINE_SOLID:
 164       win32_gc->pen_style |= PS_SOLID;
 165       break;
 166     case GDK_LINE_ON_OFF_DASH:
 167     case GDK_LINE_DOUBLE_DASH:
 168       if (win32_gc->pen_dashes == NULL)
 169         {
 170           win32_gc->pen_dashes = g_new (DWORD, 1);
 171           win32_gc->pen_dashes[0] = 4;
 172           win32_gc->pen_num_dashes = 1;
 173         }
 174
 175       if (!(win32_gc->pen_style & PS_TYPE_MASK) == PS_GEOMETRIC &&
 176           win32_gc->pen_dashes[0] == 1 &&
 177           (win32_gc->pen_num_dashes == 1 ||
 178            (win32_gc->pen_num_dashes == 2 && win32_gc->pen_dashes[0] == 1)))
 179         win32_gc->pen_style |= PS_ALTERNATE;
 180       else
 181         win32_gc->pen_style |= PS_USERSTYLE;
 182      break;
 183     }
 184
 185   /* Last, for if the GDI pen is geometric, set the join attribute */
 186   if ((win32_gc->pen_style & PS_TYPE_MASK) == PS_GEOMETRIC)
 187     {
 188       switch (win32_gc->join_style)
 189         {
 190         case GDK_JOIN_MITER:
 191           win32_gc->pen_style |= PS_JOIN_MITER;
 192           break;
 193         case GDK_JOIN_ROUND:
 194           win32_gc->pen_style |= PS_JOIN_ROUND;
 195           break;
 196         case GDK_JOIN_BEVEL:
 197           win32_gc->pen_style |= PS_JOIN_BEVEL;
 198           break;
 199         }
 200     }
 201 }
 202
 203 static void
 204 gdk_win32_gc_values_to_win32values (GdkGCValues    *values,
 205                                     GdkGCValuesMask mask,
 206                                     GdkGCWin32     *win32_gc)
 207 {
 208   char *s = "";
 209
 210   GDK_NOTE (GC, g_print ("{"));
 211
 212   if (mask & GDK_GC_FOREGROUND)
 213     {
 214       win32_gc->values_mask |= GDK_GC_FOREGROUND;
 215       GDK_NOTE (GC, (g_print ("fg=%.06x",
 216                               _gdk_gc_get_fg_pixel (&win32_gc->parent_instance)),
 217                      s = ","));
 218     }
 219
 220   if (mask & GDK_GC_BACKGROUND)
 221     {
 222       win32_gc->values_mask |= GDK_GC_BACKGROUND;
 223       GDK_NOTE (GC, (g_print ("%sbg=%.06x", s,
 224                               _gdk_gc_get_bg_pixel (&win32_gc->parent_instance)),
 225                      s = ","));
 226     }
 227
 228   if ((mask & GDK_GC_FONT) && (values->font->type == GDK_FONT_FONT
 229                                || values->font->type == GDK_FONT_FONTSET))
 230     {
 231       if (win32_gc->font != NULL)
 232         gdk_font_unref (win32_gc->font);
 233       win32_gc->font = values->font;
 234       if (win32_gc->font != NULL)
 235         {
 236           gdk_font_ref (win32_gc->font);
 237           win32_gc->values_mask |= GDK_GC_FONT;
 238           GDK_NOTE (GC, (g_print ("%sfont=%p", s, win32_gc->font),
 239                          s = ","));
 240         }
 241       else
 242         {
 243           win32_gc->values_mask &= ~GDK_GC_FONT;
 244           GDK_NOTE (GC, (g_print ("%sfont=NULL", s),
 245                          s = ","));
 246         }
 247     }
 248
 249   if (mask & GDK_GC_FUNCTION)
 250     {
 251       GDK_NOTE (GC, (g_print ("%srop2=", s),
 252                      s = ","));
 253       switch (values->function)
 254         {
 255 #define CASE(x,y) case GDK_##x: win32_gc->rop2 = R2_##y; GDK_NOTE (GC, g_print (#y)); break
 256         CASE (COPY, COPYPEN);
 257         CASE (INVERT, NOT);
 258         CASE (XOR, XORPEN);
 259         CASE (CLEAR, BLACK);
 260         CASE (AND, MASKPEN);
 261         CASE (AND_REVERSE, MASKPENNOT);
 262         CASE (AND_INVERT, MASKNOTPEN);
 263         CASE (NOOP, NOP);
 264         CASE (OR, MERGEPEN);
 265         CASE (EQUIV, NOTXORPEN);
 266         CASE (OR_REVERSE, MERGEPENNOT);
 267         CASE (COPY_INVERT, NOTCOPYPEN);
 268         CASE (OR_INVERT, MERGENOTPEN);
 269         CASE (NAND, NOTMASKPEN);
 270         CASE (NOR, NOTMERGEPEN);
 271         CASE (SET, WHITE);
 272 #undef CASE
 273         }
 274       win32_gc->values_mask |= GDK_GC_FUNCTION;
 275     }
 276
 277   if (mask & GDK_GC_FILL)
 278     {
 279       win32_gc->values_mask |= GDK_GC_FILL;
 280       GDK_NOTE (GC, (g_print ("%sfill=%s", s,
 281                               _gdk_win32_fill_style_to_string (values->fill)),
 282                      s = ","));
 283     }
 284
 285   if (mask & GDK_GC_TILE)
 286     {
 287       if (values->tile != NULL)
 288         {
 289           win32_gc->values_mask |= GDK_GC_TILE;
 290           GDK_NOTE (GC,
 291                     (g_print ("%stile=%p", s,
 292                               GDK_PIXMAP_HBITMAP (values->tile)),
 293                      s = ","));
 294         }
 295       else
 296         {
 297           win32_gc->values_mask &= ~GDK_GC_TILE;
 298           GDK_NOTE (GC, (g_print ("%stile=NULL", s),
 299                          s = ","));
 300         }
 301     }
 302
 303   if (mask & GDK_GC_STIPPLE)
 304     {
 305       if (values->stipple != NULL)
 306         {
 307           win32_gc->values_mask |= GDK_GC_STIPPLE;
 308           GDK_NOTE (GC,
 309                     (g_print ("%sstipple=%p", s,
 310                               GDK_PIXMAP_HBITMAP (values->stipple)),
 311                      s = ","));
 312         }
 313       else
 314         {
 315           win32_gc->values_mask &= ~GDK_GC_STIPPLE;
 316           GDK_NOTE (GC, (g_print ("%sstipple=NULL", s),
 317                          s = ","));
 318         }
 319     }
 320
 321   if (mask & GDK_GC_CLIP_MASK)
 322     {
 323       if (win32_gc->hcliprgn != NULL)
 324         DeleteObject (win32_gc->hcliprgn);
 325
 326       if (values->clip_mask != NULL)
 327         {
 328           win32_gc->hcliprgn = _gdk_win32_bitmap_to_hrgn (values->clip_mask);
 329           win32_gc->values_mask |= GDK_GC_CLIP_MASK;
 330         }
 331       else
 332         {
 333           win32_gc->hcliprgn = NULL;
 334           win32_gc->values_mask &= ~GDK_GC_CLIP_MASK;
 335         }
 336       GDK_NOTE (GC, (g_print ("%sclip=%p", s, win32_gc->hcliprgn),
 337                      s = ","));
 338     }
 339
 340   if (mask & GDK_GC_SUBWINDOW)
 341     {
 342       win32_gc->subwindow_mode = values->subwindow_mode;
 343       win32_gc->values_mask |= GDK_GC_SUBWINDOW;
 344       GDK_NOTE (GC, (g_print ("%ssubw=%d", s, win32_gc->subwindow_mode),
 345                      s = ","));
 346     }
 347
 348   if (mask & GDK_GC_TS_X_ORIGIN)
 349     {
 350       win32_gc->values_mask |= GDK_GC_TS_X_ORIGIN;
 351       GDK_NOTE (GC, (g_print ("%sts_x=%d", s, values->ts_x_origin),
 352                      s = ","));
 353     }
 354
 355   if (mask & GDK_GC_TS_Y_ORIGIN)
 356     {
 357       win32_gc->values_mask |= GDK_GC_TS_Y_ORIGIN;
 358       GDK_NOTE (GC, (g_print ("%sts_y=%d", s, values->ts_y_origin),
 359                      s = ","));
 360     }
 361
 362   if (mask & GDK_GC_CLIP_X_ORIGIN)
 363     {
 364       win32_gc->values_mask |= GDK_GC_CLIP_X_ORIGIN;
 365       GDK_NOTE (GC, (g_print ("%sclip_x=%d", s, values->clip_x_origin),
 366                      s = ","));
 367     }
 368
 369   if (mask & GDK_GC_CLIP_Y_ORIGIN)
 370     {
 371       win32_gc->values_mask |= GDK_GC_CLIP_Y_ORIGIN;
 372       GDK_NOTE (GC, (g_print ("%sclip_y=%d", s, values->clip_y_origin),
 373                      s = ","));
 374     }
 375
 376   if (mask & GDK_GC_EXPOSURES)
 377     {
 378       win32_gc->graphics_exposures = values->graphics_exposures;
 379       win32_gc->values_mask |= GDK_GC_EXPOSURES;
 380       GDK_NOTE (GC, (g_print ("%sexp=%d", s, win32_gc->graphics_exposures),
 381                      s = ","));
 382     }
 383
 384   if (mask & GDK_GC_LINE_WIDTH)
 385     {
 386       win32_gc->pen_width = values->line_width;
 387       win32_gc->values_mask |= GDK_GC_LINE_WIDTH;
 388       GDK_NOTE (GC, (g_print ("%spw=%d", s, win32_gc->pen_width),
 389                      s = ","));
 390     }
 391
 392   if (mask & GDK_GC_LINE_STYLE)
 393     {
 394       win32_gc->line_style = values->line_style;
 395       win32_gc->values_mask |= GDK_GC_LINE_STYLE;
 396     }
 397
 398   if (mask & GDK_GC_CAP_STYLE)
 399     {
 400       win32_gc->cap_style = values->cap_style;
 401       win32_gc->values_mask |= GDK_GC_CAP_STYLE;
 402     }
 403
 404   if (mask & GDK_GC_JOIN_STYLE)
 405     {
 406       win32_gc->join_style = values->join_style;
 407       win32_gc->values_mask |= GDK_GC_JOIN_STYLE;
 408     }
 409
 410   if (mask & (GDK_GC_LINE_WIDTH|GDK_GC_LINE_STYLE|GDK_GC_CAP_STYLE|GDK_GC_JOIN_STYLE))
 411     {
 412       fixup_pen (win32_gc);
 413       GDK_NOTE (GC, (g_print ("%sps|=PS_STYLE_%s|PS_ENDCAP_%s|PS_JOIN_%s", s,
 414                               _gdk_win32_psstyle_to_string (win32_gc->pen_style),
 415                               _gdk_win32_psendcap_to_string (win32_gc->pen_style),
 416                               _gdk_win32_psjoin_to_string (win32_gc->pen_style)),
 417                      s = ","));
 418     }
 419
 420   GDK_NOTE (GC, g_print ("} mask=(%s)", _gdk_win32_gcvalues_mask_to_string (win32_gc->values_mask)));
 421 }
 422
 423 GdkGC*
 424 _gdk_win32_gc_new (GdkDrawable    *drawable,
 425                    GdkGCValues    *values,
 426                    GdkGCValuesMask values_mask)
 427 {
 428   GdkGC *gc;
 429   GdkGCWin32 *win32_gc;
 430
 431   /* NOTICE that the drawable here has to be the impl drawable,
 432    * not the publically-visible drawables.
 433    */
 434   g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_WIN32 (drawable), NULL);
 435
 436   gc = g_object_new (_gdk_gc_win32_get_type (), NULL);
 437   win32_gc = GDK_GC_WIN32 (gc);
 438
 439   _gdk_gc_init (gc, drawable, values, values_mask);
 440
 441   win32_gc->hcliprgn = NULL;
 442
 443   win32_gc->font = NULL;
 444   win32_gc->rop2 = R2_COPYPEN;
 445   win32_gc->subwindow_mode = GDK_CLIP_BY_CHILDREN;
 446   win32_gc->graphics_exposures = TRUE;
 447   win32_gc->pen_width = 0;
 448   /* Don't get confused by the PS_ENDCAP_ROUND. For narrow GDI pens
 449    * (width == 1), PS_GEOMETRIC|PS_ENDCAP_ROUND works like X11's
 450    * CapButt.
 451    */
 452   win32_gc->pen_style = PS_GEOMETRIC|PS_ENDCAP_ROUND|PS_JOIN_MITER;
 453   win32_gc->line_style = GDK_LINE_SOLID;
 454   win32_gc->cap_style = GDK_CAP_BUTT;
 455   win32_gc->join_style = GDK_JOIN_MITER;
 456   win32_gc->pen_dashes = NULL;
 457   win32_gc->pen_num_dashes = 0;
 458   win32_gc->pen_dash_offset = 0;
 459   win32_gc->pen_hbrbg = NULL;
 460
 461   win32_gc->values_mask = GDK_GC_FUNCTION | GDK_GC_FILL;
 462
 463   GDK_NOTE (GC, g_print ("_gdk_win32_gc_new: %p: ", win32_gc));
 464   gdk_win32_gc_values_to_win32values (values, values_mask, win32_gc);
 465   GDK_NOTE (GC, g_print ("\n"));
 466
 467   win32_gc->hdc = NULL;
 468
 469   return gc;
 470 }
 471
 472 static void
 473 gdk_win32_gc_get_values (GdkGC       *gc,
 474                          GdkGCValues *values)
 475 {
 476   GdkGCWin32 *win32_gc = GDK_GC_WIN32 (gc);
 477
 478   values->foreground.pixel = _gdk_gc_get_fg_pixel (gc);
 479   values->background.pixel = _gdk_gc_get_bg_pixel (gc);
 480   values->font = win32_gc->font;
 481
 482   switch (win32_gc->rop2)
 483     {
 484     case R2_COPYPEN:
 485       values->function = GDK_COPY; break;
 486     case R2_NOT:
 487       values->function = GDK_INVERT; break;
 488     case R2_XORPEN:
 489       values->function = GDK_XOR; break;
 490     case R2_BLACK:
 491       values->function = GDK_CLEAR; break;
 492     case R2_MASKPEN:
 493       values->function = GDK_AND; break;
 494     case R2_MASKPENNOT:
 495       values->function = GDK_AND_REVERSE; break;
 496     case R2_MASKNOTPEN:
 497       values->function = GDK_AND_INVERT; break;
 498     case R2_NOP:
 499       values->function = GDK_NOOP; break;
 500     case R2_MERGEPEN:
 501       values->function = GDK_OR; break;
 502     case R2_NOTXORPEN:
 503       values->function = GDK_EQUIV; break;
 504     case R2_MERGEPENNOT:
 505       values->function = GDK_OR_REVERSE; break;
 506     case R2_NOTCOPYPEN:
 507       values->function = GDK_COPY_INVERT; break;
 508     case R2_MERGENOTPEN:
 509       values->function = GDK_OR_INVERT; break;
 510     case R2_NOTMASKPEN:
 511       values->function = GDK_NAND; break;
 512     case R2_NOTMERGEPEN:
 513       values->function = GDK_NOR; break;
 514     case R2_WHITE:
 515       values->function = GDK_SET; break;
 516     }
 517
 518   values->fill = _gdk_gc_get_fill (gc);
 519   values->tile = _gdk_gc_get_tile (gc);
 520   values->stipple = _gdk_gc_get_stipple (gc);
 521
 522   /* Also the X11 backend always returns a NULL clip_mask */
 523   values->clip_mask = NULL;
 524
 525   values->subwindow_mode = win32_gc->subwindow_mode;
 526   values->ts_x_origin = win32_gc->parent_instance.ts_x_origin;
 527   values->ts_y_origin = win32_gc->parent_instance.ts_y_origin;
 528   values->clip_x_origin = win32_gc->parent_instance.clip_x_origin;
 529   values->clip_y_origin = win32_gc->parent_instance.clip_y_origin;
 530   values->graphics_exposures = win32_gc->graphics_exposures;
 531   values->line_width = win32_gc->pen_width;
 532
 533   values->line_style = win32_gc->line_style;
 534   values->cap_style = win32_gc->cap_style;
 535   values->join_style = win32_gc->join_style;
 536 }
 537
 538 static void
 539 gdk_win32_gc_set_values (GdkGC           *gc,
 540                          GdkGCValues     *values,
 541                          GdkGCValuesMask  mask)
 542 {
 543   g_return_if_fail (GDK_IS_GC (gc));
 544
 545   GDK_NOTE (GC, g_print ("gdk_win32_gc_set_values: %p: ", GDK_GC_WIN32 (gc)));
 546   gdk_win32_gc_values_to_win32values (values, mask, GDK_GC_WIN32 (gc));
 547   GDK_NOTE (GC, g_print ("\n"));
 548 }
 549
 550 static void
 551 gdk_win32_gc_set_dashes (GdkGC *gc,
 552                          gint   dash_offset,
 553                          gint8  dash_list[],
 554                          gint   n)
 555 {
 556   GdkGCWin32 *win32_gc;
 557   int i;
 558
 559   g_return_if_fail (GDK_IS_GC (gc));
 560   g_return_if_fail (dash_list != NULL);
 561
 562   win32_gc = GDK_GC_WIN32 (gc);
 563
 564   win32_gc->pen_num_dashes = n;
 565   g_free (win32_gc->pen_dashes);
 566   win32_gc->pen_dashes = g_new (DWORD, n);
 567   for (i = 0; i < n; i++)
 568     win32_gc->pen_dashes[i] = dash_list[i];
 569   win32_gc->pen_dash_offset = dash_offset;
 570   fixup_pen (win32_gc);
 571 }
 572
 573 void
 574 _gdk_windowing_gc_set_clip_region (GdkGC           *gc,
 575                                    const GdkRegion *region)
 576 {
 577   GdkGCWin32 *win32_gc = GDK_GC_WIN32 (gc);
 578
 579   if (win32_gc->hcliprgn)
 580     DeleteObject (win32_gc->hcliprgn);
 581
 582   if (region)
 583     {
 584       GDK_NOTE (GC, g_print ("gdk_gc_set_clip_region: %p: %s\n",
 585                              win32_gc,
 586                              _gdk_win32_gdkregion_to_string (region)));
 587
 588       win32_gc->hcliprgn = _gdk_win32_gdkregion_to_hrgn (region, 0, 0);
 589       win32_gc->values_mask |= GDK_GC_CLIP_MASK;
 590     }
 591   else
 592     {
 593       GDK_NOTE (GC, g_print ("gdk_gc_set_clip_region: NULL\n"));
 594
 595       win32_gc->hcliprgn = NULL;
 596       win32_gc->values_mask &= ~GDK_GC_CLIP_MASK;
 597     }
 598
 599   gc->clip_x_origin = 0;
 600   gc->clip_y_origin = 0;
 601
 602   win32_gc->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
 603 }
 604
 605 void
 606 _gdk_windowing_gc_copy (GdkGC *dst_gc,
 607                         GdkGC *src_gc)
 608 {
 609   GdkGCWin32 *dst_win32_gc = GDK_GC_WIN32 (dst_gc);
 610   GdkGCWin32 *src_win32_gc = GDK_GC_WIN32 (src_gc);
 611
 612   GDK_NOTE (GC, g_print ("gdk_gc_copy: %p := %p\n", dst_win32_gc, src_win32_gc));
 613
 614   if (dst_win32_gc->hcliprgn != NULL)
 615     DeleteObject (dst_win32_gc->hcliprgn);
 616
 617   if (dst_win32_gc->font != NULL)
 618     gdk_font_unref (dst_win32_gc->font);
 619
 620   g_free (dst_win32_gc->pen_dashes);
 621
 622   dst_win32_gc->hcliprgn = src_win32_gc->hcliprgn;
 623   if (dst_win32_gc->hcliprgn)
 624     {
 625       /* create a new region, to copy to */
 626       dst_win32_gc->hcliprgn = CreateRectRgn (0,0,1,1);
 627       /* overwrite from source */
 628       CombineRgn (dst_win32_gc->hcliprgn, src_win32_gc->hcliprgn,
 629                   NULL, RGN_COPY);
 630     }
 631
 632   dst_win32_gc->values_mask = src_win32_gc->values_mask;
 633   dst_win32_gc->font = src_win32_gc->font;
 634   if (dst_win32_gc->font != NULL)
 635     gdk_font_ref (dst_win32_gc->font);
 636
 637   dst_win32_gc->rop2 = src_win32_gc->rop2;
 638
 639   dst_win32_gc->subwindow_mode = src_win32_gc->subwindow_mode;
 640   dst_win32_gc->graphics_exposures = src_win32_gc->graphics_exposures;
 641   dst_win32_gc->pen_width = src_win32_gc->pen_width;
 642   dst_win32_gc->pen_style = src_win32_gc->pen_style;
 643   dst_win32_gc->line_style = src_win32_gc->line_style;
 644   dst_win32_gc->cap_style = src_win32_gc->cap_style;
 645   dst_win32_gc->join_style = src_win32_gc->join_style;
 646   if (src_win32_gc->pen_dashes)
 647     dst_win32_gc->pen_dashes = g_memdup (src_win32_gc->pen_dashes,
 648                                          sizeof (DWORD) * src_win32_gc->pen_num_dashes);
 649   else
 650     dst_win32_gc->pen_dashes = NULL;
 651   dst_win32_gc->pen_num_dashes = src_win32_gc->pen_num_dashes;
 652   dst_win32_gc->pen_dash_offset = src_win32_gc->pen_dash_offset;
 653
 654
 655   dst_win32_gc->hdc = NULL;
 656   dst_win32_gc->saved_dc = FALSE;
 657   dst_win32_gc->holdpal = NULL;
 658   dst_win32_gc->pen_hbrbg = NULL;
 659 }
 660
 661 GdkScreen *
 662 gdk_gc_get_screen (GdkGC *gc)
 663 {
 664   g_return_val_if_fail (GDK_IS_GC_WIN32 (gc), NULL);
 665
 666   return _gdk_screen;
 667 }
 668
 669 static guint bitmask[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
 670
 671 COLORREF
 672 _gdk_win32_colormap_color (GdkColormap *colormap,
 673                            gulong       pixel)
 674 {
 675   const GdkVisual *visual;
 676   GdkColormapPrivateWin32 *colormap_private;
 677   guchar r, g, b;
 678
 679   if (colormap == NULL)
 680     return DIBINDEX (pixel & 1);
 681
 682   colormap_private = GDK_WIN32_COLORMAP_DATA (colormap);
 683
 684   g_assert (colormap_private != NULL);
 685
 686   visual = colormap->visual;
 687   switch (visual->type)
 688     {
 689     case GDK_VISUAL_GRAYSCALE:
 690     case GDK_VISUAL_PSEUDO_COLOR:
 691     case GDK_VISUAL_STATIC_COLOR:
 692       return PALETTEINDEX (pixel);
 693
 694     case GDK_VISUAL_TRUE_COLOR:
 695       r = (pixel & visual->red_mask) >> visual->red_shift;
 696       r = (r * 255) / bitmask[visual->red_prec];
 697       g = (pixel & visual->green_mask) >> visual->green_shift;
 698       g = (g * 255) / bitmask[visual->green_prec];
 699       b = (pixel & visual->blue_mask) >> visual->blue_shift;
 700       b = (b * 255) / bitmask[visual->blue_prec];
 701       return RGB (r, g, b);
 702
 703     default:
 704       g_assert_not_reached ();
 705       return 0;
 706     }
 707 }
 708
 709 gboolean
 710 predraw (GdkGC       *gc,
 711          GdkColormap *colormap)
 712 {
 713   GdkGCWin32 *win32_gc = (GdkGCWin32 *) gc;
 714   GdkColormapPrivateWin32 *colormap_private;
 715   gint k;
 716   gboolean ok = TRUE;
 717
 718   if (colormap &&
 719       (colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR ||
 720        colormap->visual->type == GDK_VISUAL_STATIC_COLOR))
 721     {
 722       colormap_private = GDK_WIN32_COLORMAP_DATA (colormap);
 723
 724       g_assert (colormap_private != NULL);
 725
 726       if (!(win32_gc->holdpal = SelectPalette (win32_gc->hdc, colormap_private->hpal, FALSE)))
 727         WIN32_GDI_FAILED ("SelectPalette"), ok = FALSE;
 728       else if ((k = RealizePalette (win32_gc->hdc)) == GDI_ERROR)
 729         WIN32_GDI_FAILED ("RealizePalette"), ok = FALSE;
 730       else if (k > 0)
 731         GDK_NOTE (COLORMAP, g_print ("predraw: realized %p: %d colors\n",
 732                                      colormap_private->hpal, k));
 733     }
 734
 735   return ok;
 736 }
 737
 738 static GdkDrawableImplWin32 *
 739 get_impl_drawable (GdkDrawable *drawable)
 740 {
 741   if (GDK_IS_DRAWABLE_IMPL_WIN32 (drawable))
 742     return GDK_DRAWABLE_IMPL_WIN32(drawable);
 743   else if (GDK_IS_WINDOW (drawable))
 744     return GDK_DRAWABLE_IMPL_WIN32 ((GDK_WINDOW_OBJECT (drawable))->impl);
 745   else if (GDK_IS_PIXMAP (drawable))
 746     return GDK_DRAWABLE_IMPL_WIN32 ((GDK_PIXMAP_OBJECT (drawable))->impl);
 747   else
 748     g_assert_not_reached ();
 749
 750   return NULL;
 751 }
 752
 753 /**
 754  * gdk_win32_hdc_get:
 755  * @drawable: destination #GdkDrawable
 756  * @gc: #GdkGC to use for drawing on @drawable
 757  * @usage: mask indicating what properties needs to be set up
 758  *
 759  * Allocates a Windows device context handle (HDC) for drawing into
 760  * @drawable, and sets it up appropriately according to @usage.
 761  *
 762  * Each #GdkGC can at one time have only one HDC associated with it.
 763  *
 764  * The following flags in @mask are handled:
 765  *
 766  * If %GDK_GC_FOREGROUND is set in @mask, a solid brush of the
 767  * foreground color in @gc is selected into the HDC. The text color of
 768  * the HDC is also set. If the @drawable has a palette (256-color
 769  * mode), the palette is selected and realized.
 770  *
 771  * If any of the line attribute flags (%GDK_GC_LINE_WIDTH,
 772  * %GDK_GC_LINE_STYLE, %GDK_GC_CAP_STYLE and %GDK_GC_JOIN_STYLE) is
 773  * set in @mask, a solid pen of the foreground color and appropriate
 774  * width and stule is created and selected into the HDC. Note that the
 775  * dash properties are not completely implemented.
 776  *
 777  * If the %GDK_GC_FONT flag is set, the background mix mode is set to
 778  * %TRANSPARENT. and the text alignment is set to
 779  * %TA_BASELINE|%TA_LEFT. Note that no font gets selected into the HDC
 780  * by this function.
 781  *
 782  * Some things are done regardless of @mask: If the function in @gc is
 783  * any other than %GDK_COPY, the raster operation of the HDC is
 784  * set. If @gc has a clip mask, the clip region of the HDC is set.
 785  *
 786  * Note that the fill style, tile, stipple, and tile and stipple
 787  * origins in the @gc are ignored by this function. (In general, tiles
 788  * and stipples can't be implemented directly on Win32; you need to do
 789  * multiple pass drawing and blitting to implement tiles or
 790  * stipples. GDK does just that when you call the GDK drawing
 791  * functions with a GC that asks for tiles or stipples.)
 792  *
 793  * When the HDC is no longer used, it should be released by calling
 794  * <function>gdk_win32_hdc_release()</function> with the same
 795  * parameters.
 796  *
 797  * If you modify the HDC by calling <function>SelectObject</function>
 798  * you should undo those modifications before calling
 799  * <function>gdk_win32_hdc_release()</function>.
 800  *
 801  * Return value: The HDC.
 802  **/
 803 HDC
 804 gdk_win32_hdc_get (GdkDrawable    *drawable,
 805                    GdkGC          *gc,
 806                    GdkGCValuesMask usage)
 807 {
 808   GdkGCWin32 *win32_gc = (GdkGCWin32 *) gc;
 809   GdkDrawableImplWin32 *impl = NULL;
 810   gboolean ok = TRUE;
 811   COLORREF fg = RGB (0, 0, 0), bg = RGB (255, 255, 255);
 812   HPEN hpen;
 813   HBRUSH hbr;
 814
 815   g_assert (win32_gc->hdc == NULL);
 816
 817   impl = get_impl_drawable (drawable);
 818
 819   win32_gc->hdc = _gdk_win32_drawable_acquire_dc (GDK_DRAWABLE (impl));
 820   ok = win32_gc->hdc != NULL;
 821
 822   if (ok && (win32_gc->saved_dc = SaveDC (win32_gc->hdc)) == 0)
 823     WIN32_GDI_FAILED ("SaveDC"), ok = FALSE;
 824
 825   if (ok && (usage & (GDK_GC_FOREGROUND | GDK_GC_BACKGROUND)))
 826       ok = predraw (gc, impl->colormap);
 827
 828   if (ok && (usage & GDK_GC_FOREGROUND))
 829     {
 830       fg = _gdk_win32_colormap_color (impl->colormap, _gdk_gc_get_fg_pixel (gc));
 831       if ((hbr = CreateSolidBrush (fg)) == NULL)
 832         WIN32_GDI_FAILED ("CreateSolidBrush"), ok = FALSE;
 833
 834       if (ok && SelectObject (win32_gc->hdc, hbr) == NULL)
 835         WIN32_GDI_FAILED ("SelectObject"), ok = FALSE;
 836
 837       if (ok && SetTextColor (win32_gc->hdc, fg) == CLR_INVALID)
 838         WIN32_GDI_FAILED ("SetTextColor"), ok = FALSE;
 839     }
 840
 841   if (ok && (usage & LINE_ATTRIBUTES))
 842     {
 843       /* For drawing GDK_LINE_DOUBLE_DASH */
 844       if ((usage & GDK_GC_BACKGROUND) && win32_gc->line_style == GDK_LINE_DOUBLE_DASH)
 845         {
 846           bg = _gdk_win32_colormap_color (impl->colormap, _gdk_gc_get_bg_pixel (gc));
 847           if ((win32_gc->pen_hbrbg = CreateSolidBrush (bg)) == NULL)
 848             WIN32_GDI_FAILED ("CreateSolidBrush"), ok = FALSE;
 849         }
 850
 851       if (ok)
 852         {
 853           LOGBRUSH logbrush;
 854           DWORD style_count = 0;
 855           const DWORD *style = NULL;
 856
 857           /* Create and select pen */
 858           logbrush.lbStyle = BS_SOLID;
 859           logbrush.lbColor = fg;
 860           logbrush.lbHatch = 0;
 861
 862           if ((win32_gc->pen_style & PS_STYLE_MASK) == PS_USERSTYLE)
 863             {
 864               style_count = win32_gc->pen_num_dashes;
 865               style = win32_gc->pen_dashes;
 866             }
 867
 868           if ((hpen = ExtCreatePen (win32_gc->pen_style,
 869                                     MAX (win32_gc->pen_width, 1),
 870                                     &logbrush,
 871                                     style_count, style)) == NULL)
 872             WIN32_GDI_FAILED ("ExtCreatePen"), ok = FALSE;
 873
 874           if (ok && SelectObject (win32_gc->hdc, hpen) == NULL)
 875             WIN32_GDI_FAILED ("SelectObject"), ok = FALSE;
 876         }
 877     }
 878
 879   if (ok && (usage & GDK_GC_FONT))
 880     {
 881       if (SetBkMode (win32_gc->hdc, TRANSPARENT) == 0)
 882         WIN32_GDI_FAILED ("SetBkMode"), ok = FALSE;
 883
 884       if (ok && SetTextAlign (win32_gc->hdc, TA_BASELINE|TA_LEFT|TA_NOUPDATECP) == GDI_ERROR)
 885         WIN32_GDI_FAILED ("SetTextAlign"), ok = FALSE;
 886     }
 887
 888   if (ok && win32_gc->rop2 != R2_COPYPEN)
 889     if (SetROP2 (win32_gc->hdc, win32_gc->rop2) == 0)
 890       WIN32_GDI_FAILED ("SetROP2"), ok = FALSE;
 891
 892   if (ok &&
 893       (win32_gc->values_mask & GDK_GC_CLIP_MASK) &&
 894       win32_gc->hcliprgn != NULL)
 895     {
 896       if (SelectClipRgn (win32_gc->hdc, win32_gc->hcliprgn) == ERROR)
 897         WIN32_API_FAILED ("SelectClipRgn"), ok = FALSE;
 898
 899       if (ok && win32_gc->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN) &&
 900           OffsetClipRgn (win32_gc->hdc,
 901             win32_gc->values_mask & GDK_GC_CLIP_X_ORIGIN ? gc->clip_x_origin : 0,
 902             win32_gc->values_mask & GDK_GC_CLIP_Y_ORIGIN ? gc->clip_y_origin : 0) == ERROR)
 903         WIN32_API_FAILED ("OffsetClipRgn"), ok = FALSE;
 904     }
 905   else if (ok)
 906     SelectClipRgn (win32_gc->hdc, NULL);
 907
 908   GDK_NOTE (GC, (g_print ("gdk_win32_hdc_get: %p (%s): ",
 909                           win32_gc, _gdk_win32_gcvalues_mask_to_string (usage)),
 910                  _gdk_win32_print_dc (win32_gc->hdc)));
 911
 912   return win32_gc->hdc;
 913 }
 914
 915 /**
 916  * gdk_win32_hdc_release:
 917  * @drawable: destination #GdkDrawable
 918  * @gc: #GdkGC to use for drawing on @drawable
 919  * @usage: mask indicating what properties were set up
 920  *
 921  * This function deallocates the Windows device context allocated by
 922  * <funcion>gdk_win32_hdc_get()</function>. It should be called with
 923  * the same parameters.
 924  **/
 925 void
 926 gdk_win32_hdc_release (GdkDrawable    *drawable,
 927                        GdkGC          *gc,
 928                        GdkGCValuesMask usage)
 929 {
 930   GdkGCWin32 *win32_gc = (GdkGCWin32 *) gc;
 931   GdkDrawableImplWin32 *impl = NULL;
 932   HGDIOBJ hpen = NULL;
 933   HGDIOBJ hbr = NULL;
 934
 935   GDK_NOTE (GC, g_print ("gdk_win32_hdc_release: %p: %p (%s)\n",
 936                          win32_gc, win32_gc->hdc,
 937                          _gdk_win32_gcvalues_mask_to_string (usage)));
 938
 939   impl = get_impl_drawable (drawable);
 940
 941   if (win32_gc->holdpal != NULL)
 942     {
 943       gint k;
 944
 945       if (!SelectPalette (win32_gc->hdc, win32_gc->holdpal, FALSE))
 946         WIN32_GDI_FAILED ("SelectPalette");
 947       else if ((k = RealizePalette (win32_gc->hdc)) == GDI_ERROR)
 948         WIN32_GDI_FAILED ("RealizePalette");
 949       else if (k > 0)
 950         GDK_NOTE (COLORMAP, g_print ("gdk_win32_hdc_release: realized %p: %d colors\n",
 951                                      win32_gc->holdpal, k));
 952       win32_gc->holdpal = NULL;
 953     }
 954
 955   if (usage & LINE_ATTRIBUTES)
 956     if ((hpen = GetCurrentObject (win32_gc->hdc, OBJ_PEN)) == NULL)
 957       WIN32_GDI_FAILED ("GetCurrentObject");
 958
 959   if (usage & GDK_GC_FOREGROUND)
 960     if ((hbr = GetCurrentObject (win32_gc->hdc, OBJ_BRUSH)) == NULL)
 961       WIN32_GDI_FAILED ("GetCurrentObject");
 962
 963   GDI_CALL (RestoreDC, (win32_gc->hdc, win32_gc->saved_dc));
 964
 965   _gdk_win32_drawable_release_dc (GDK_DRAWABLE (impl));
 966
 967   if (hpen != NULL)
 968     GDI_CALL (DeleteObject, (hpen));
 969
 970   if (hbr != NULL)
 971     GDI_CALL (DeleteObject, (hbr));
 972
 973   if (win32_gc->pen_hbrbg != NULL)
 974     GDI_CALL (DeleteObject, (win32_gc->pen_hbrbg));
 975
 976   win32_gc->hdc = NULL;
 977 }
 978
 979 /* This function originally from Jean-Edouard Lachand-Robert, and
 980  * available at www.codeguru.com. Simplified for our needs, not sure
 981  * how much of the original code left any longer. Now handles just
 982  * one-bit deep bitmaps (in Window parlance, ie those that GDK calls
 983  * bitmaps (and not pixmaps), with zero pixels being transparent.
 984  */
 985
 986 /* _gdk_win32_bitmap_to_hrgn : Create a region from the
 987  * "non-transparent" pixels of a bitmap.
 988  */
 989
 990 HRGN
 991 _gdk_win32_bitmap_to_hrgn (GdkPixmap *pixmap)
 992 {
 993   HRGN hRgn = NULL;
 994   HRGN h;
 995   DWORD maxRects;
 996   RGNDATA *pData;
 997   guchar *bits;
 998   gint width, height, bpl;
 999   guchar *p;
1000   gint x, y;
1001
1002   g_assert (GDK_PIXMAP_OBJECT(pixmap)->depth == 1);
1003
1004   bits = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl)->bits;
1005   width = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl)->width;
1006   height = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl)->height;
1007   bpl = ((width - 1)/32 + 1)*4;
1008
1009   /* For better performances, we will use the ExtCreateRegion()
1010    * function to create the region. This function take a RGNDATA
1011    * structure on entry. We will add rectangles by amount of
1012    * ALLOC_UNIT number in this structure.
1013    */
1014   #define ALLOC_UNIT  100
1015   maxRects = ALLOC_UNIT;
1016
1017   pData = g_malloc (sizeof (RGNDATAHEADER) + (sizeof (RECT) * maxRects));
1018   pData->rdh.dwSize = sizeof (RGNDATAHEADER);
1019   pData->rdh.iType = RDH_RECTANGLES;
1020   pData->rdh.nCount = pData->rdh.nRgnSize = 0;
1021   SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1022
1023   for (y = 0; y < height; y++)
1024     {
1025       /* Scan each bitmap row from left to right*/
1026       p = (guchar *) bits + y * bpl;
1027       for (x = 0; x < width; x++)
1028         {
1029           /* Search for a continuous range of "non transparent pixels"*/
1030           gint x0 = x;
1031           while (x < width)
1032             {
1033               if ((((p[x/8])>>(7-(x%8)))&1) == 0)
1034                 /* This pixel is "transparent"*/
1035                 break;
1036               x++;
1037             }
1038
1039           if (x > x0)
1040             {
1041               RECT *pr;
1042               /* Add the pixels (x0, y) to (x, y+1) as a new rectangle
1043                * in the region
1044                */
1045               if (pData->rdh.nCount >= maxRects)
1046                 {
1047                   maxRects += ALLOC_UNIT;
1048                   pData = g_realloc (pData, sizeof(RGNDATAHEADER)
1049                                      + (sizeof(RECT) * maxRects));
1050                 }
1051               pr = (RECT *) &pData->Buffer;
1052               SetRect (&pr[pData->rdh.nCount], x0, y, x, y+1);
1053               if (x0 < pData->rdh.rcBound.left)
1054                 pData->rdh.rcBound.left = x0;
1055               if (y < pData->rdh.rcBound.top)
1056                 pData->rdh.rcBound.top = y;
1057               if (x > pData->rdh.rcBound.right)
1058                 pData->rdh.rcBound.right = x;
1059               if (y+1 > pData->rdh.rcBound.bottom)
1060                 pData->rdh.rcBound.bottom = y+1;
1061               pData->rdh.nCount++;
1062
1063               /* On Windows98, ExtCreateRegion() may fail if the
1064                * number of rectangles is too large (ie: >
1065                * 4000). Therefore, we have to create the region by
1066                * multiple steps.
1067                */
1068               if (pData->rdh.nCount == 2000)
1069                 {
1070                   HRGN h = ExtCreateRegion (NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
1071                   if (hRgn)
1072                     {
1073                       CombineRgn(hRgn, hRgn, h, RGN_OR);
1074                       DeleteObject(h);
1075                     }
1076                   else
1077                     hRgn = h;
1078                   pData->rdh.nCount = 0;
1079                   SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1080                 }
1081             }
1082         }
1083     }
1084
1085   /* Create or extend the region with the remaining rectangles*/
1086   h = ExtCreateRegion (NULL, sizeof (RGNDATAHEADER)
1087                        + (sizeof (RECT) * maxRects), pData);
1088   if (hRgn)
1089     {
1090       CombineRgn (hRgn, hRgn, h, RGN_OR);
1091       DeleteObject (h);
1092     }
1093   else
1094     hRgn = h;
1095
1096   /* Clean up*/
1097   g_free (pData);
1098
1099   return hRgn;
1100 }
1101
1102 HRGN
1103 _gdk_win32_gdkregion_to_hrgn (const GdkRegion *region,
1104                               gint             x_origin,
1105                               gint             y_origin)
1106 {
1107   HRGN hrgn;
1108   RGNDATA *rgndata;
1109   RECT *rect;
1110   GdkRegionBox *boxes = region->rects;
1111   guint nbytes =
1112     sizeof (RGNDATAHEADER) + (sizeof (RECT) * region->numRects);
1113   int i;
1114
1115   rgndata = g_malloc (nbytes);
1116   rgndata->rdh.dwSize = sizeof (RGNDATAHEADER);
1117   rgndata->rdh.iType = RDH_RECTANGLES;
1118   rgndata->rdh.nCount = rgndata->rdh.nRgnSize = 0;
1119   SetRect (&rgndata->rdh.rcBound,
1120            G_MAXLONG, G_MAXLONG, G_MINLONG, G_MINLONG);
1121
1122   for (i = 0; i < region->numRects; i++)
1123     {
1124       rect = ((RECT *) rgndata->Buffer) + rgndata->rdh.nCount++;
1125
1126       rect->left = boxes[i].x1 + x_origin;
1127       rect->right = boxes[i].x2 + x_origin;
1128       rect->top = boxes[i].y1 + y_origin;
1129       rect->bottom = boxes[i].y2 + y_origin;
1130
1131       if (rect->left < rgndata->rdh.rcBound.left)
1132         rgndata->rdh.rcBound.left = rect->left;
1133       if (rect->right > rgndata->rdh.rcBound.right)
1134         rgndata->rdh.rcBound.right = rect->right;
1135       if (rect->top < rgndata->rdh.rcBound.top)
1136         rgndata->rdh.rcBound.top = rect->top;
1137       if (rect->bottom > rgndata->rdh.rcBound.bottom)
1138         rgndata->rdh.rcBound.bottom = rect->bottom;
1139     }
1140   if ((hrgn = ExtCreateRegion (NULL, nbytes, rgndata)) == NULL)
1141     WIN32_API_FAILED ("ExtCreateRegion");
1142
1143   g_free (rgndata);
1144
1145   return (hrgn);
1146 }