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  *
   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.
   8  *
   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.
  13  *
  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.
  18  */
  19
  20 /*
  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/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <string.h>
  30
  31 #include "gdkgc.h"
  32 #include "gdkfont.h"
  33 #include "gdkpixmap.h"
  34 #include "gdkprivate.h"
  35 #include "gdkwin32.h"
  36
  37 static void gdk_win32_gc_destroy    (GdkGC           *gc);
  38 static void gdk_win32_gc_get_values (GdkGC           *gc,
  39                                      GdkGCValues     *values);
  40 static void gdk_win32_gc_set_values (GdkGC           *gc,
  41                                      GdkGCValues     *values,
  42                                      GdkGCValuesMask  values_mask);
  43 static void gdk_win32_gc_set_dashes (GdkGC           *gc,
  44                                      gint             dash_offset,
  45                                      gchar            dash_list[],
  46                                      gint             n);
  47
  48 static GdkGCClass gdk_win32_gc_class = {
  49   gdk_win32_gc_destroy,
  50   gdk_win32_gc_get_values,
  51   gdk_win32_gc_set_values,
  52   gdk_win32_gc_set_dashes
  53 };
  54
  55 static void
  56 gdk_win32_gc_values_to_win32values (GdkGCValues    *values,
  57                                     GdkGCValuesMask mask,
  58                                     GdkGCWin32Data *data)
  59 {
  60   char *s = "";
  61
  62   GDK_NOTE (MISC, g_print ("{"));
  63
  64   if (mask & GDK_GC_FOREGROUND)
  65     {
  66       data->foreground = values->foreground.pixel;
  67       data->values_mask |= GDK_GC_FOREGROUND;
  68       GDK_NOTE (MISC, (g_print ("fg=%.06x", data->foreground),
  69                        s = ","));
  70     }
  71
  72   if (mask & GDK_GC_BACKGROUND)
  73     {
  74       data->background = values->background.pixel;
  75       data->values_mask |= GDK_GC_BACKGROUND;
  76       GDK_NOTE (MISC, (g_print ("%sbg=%.06x", s, data->background),
  77                        s = ","));
  78     }
  79
  80   if ((mask & GDK_GC_FONT) && (values->font->type == GDK_FONT_FONT
  81                                || values->font->type == GDK_FONT_FONTSET))
  82     {
  83       if (data->font != NULL)
  84         gdk_font_unref (data->font);
  85       data->font = values->font;
  86       if (data->font != NULL)
  87         {
  88           gchar *xlfd;
  89
  90           gdk_font_ref (data->font);
  91           data->values_mask |= GDK_GC_FONT;
  92           GDK_NOTE (MISC, (xlfd = gdk_font_full_name_get (data->font),
  93                            g_print ("%sfont=%s", s, xlfd),
  94                            s = ",",
  95                            gdk_font_full_name_free (xlfd)));
  96         }
  97       else
  98         {
  99           data->values_mask &= ~GDK_GC_FONT;
 100           GDK_NOTE (MISC, (g_print ("%sfont=NULL"),
 101                            s = ","));
 102         }
 103     }
 104
 105   if (mask & GDK_GC_FUNCTION)
 106     {
 107       GDK_NOTE (MISC, (g_print ("%srop2=", s),
 108                        s = ","));
 109       switch (values->function)
 110         {
 111         case GDK_COPY:
 112           data->rop2 = R2_COPYPEN;
 113           GDK_NOTE (MISC, g_print ("COPYPEN"));
 114           break;
 115         case GDK_INVERT:
 116           data->rop2 = R2_NOT;
 117           GDK_NOTE (MISC, g_print ("NOT"));
 118           break;
 119         case GDK_XOR:
 120           data->rop2 = R2_XORPEN;
 121           GDK_NOTE (MISC, g_print ("XORPEN"));
 122           break;
 123         case GDK_CLEAR:
 124           data->rop2 = R2_BLACK;
 125           GDK_NOTE (MISC, g_print ("BLACK"));
 126           break;
 127         case GDK_AND:
 128           data->rop2 = R2_MASKPEN;
 129           GDK_NOTE (MISC, g_print ("MASKPEN"));
 130           break;
 131         case GDK_AND_REVERSE:
 132           data->rop2 = R2_MASKPENNOT;
 133           GDK_NOTE (MISC, g_print ("MASKPENNOT"));
 134           break;
 135         case GDK_AND_INVERT:
 136           data->rop2 = R2_MASKNOTPEN;
 137           GDK_NOTE (MISC, g_print ("MASKNOTPEN"));
 138           break;
 139         case GDK_NOOP:
 140           data->rop2 = R2_NOP;
 141           GDK_NOTE (MISC, g_print ("NOP"));
 142           break;
 143         case GDK_OR:
 144           data->rop2 = R2_MERGEPEN;
 145           GDK_NOTE (MISC, g_print ("MERGEPEN"));
 146           break;
 147         case GDK_EQUIV:
 148           data->rop2 = R2_NOTXORPEN;
 149           GDK_NOTE (MISC, g_print ("NOTXORPEN"));
 150           break;
 151         case GDK_OR_REVERSE:
 152           data->rop2 = R2_MERGEPENNOT;
 153           GDK_NOTE (MISC, g_print ("MERGEPENNOT"));
 154           break;
 155         case GDK_COPY_INVERT:
 156           data->rop2 = R2_NOTCOPYPEN;
 157           GDK_NOTE (MISC, g_print ("NOTCOPYPEN"));
 158           break;
 159         case GDK_OR_INVERT:
 160           data->rop2 = R2_MERGENOTPEN;
 161           GDK_NOTE (MISC, g_print ("MERGENOTPEN"));
 162           break;
 163         case GDK_NAND:
 164           data->rop2 = R2_NOTMASKPEN;
 165           GDK_NOTE (MISC, g_print ("NOTMASKPEN"));
 166           break;
 167         case GDK_SET:
 168           data->rop2 = R2_WHITE;
 169           GDK_NOTE (MISC, g_print ("WHITE"));
 170           break;
 171         }
 172       data->values_mask |= GDK_GC_FUNCTION;
 173     }
 174
 175   if (mask & GDK_GC_FILL)
 176     {
 177       data->fill_style = values->fill;
 178       data->values_mask |= GDK_GC_FILL;
 179       GDK_NOTE (MISC, (g_print ("%sfill=%d", s, data->fill_style),
 180                        s = ","));
 181     }
 182
 183   if (mask & GDK_GC_TILE)
 184     {
 185       if (data->tile != NULL)
 186         gdk_drawable_unref (data->tile);
 187       data->tile = values->tile;
 188       if (data->tile != NULL)
 189         {
 190           gdk_drawable_ref (data->tile);
 191           data->values_mask |= GDK_GC_TILE;
 192           GDK_NOTE (MISC, (g_print ("%stile=%#x", s,
 193                                     GDK_DRAWABLE_XID (data->tile)),
 194                            s = ","));
 195         }
 196       else
 197         {
 198           data->values_mask &= ~GDK_GC_TILE;
 199           GDK_NOTE (MISC, (g_print ("%stile=NULL", s),
 200                            s = ","));
 201         }
 202     }
 203
 204   if (mask & GDK_GC_STIPPLE)
 205     {
 206       if (data->stipple != NULL)
 207         gdk_drawable_unref (data->stipple);
 208       data->stipple = values->stipple;
 209       if (data->stipple != NULL)
 210         {
 211           gdk_drawable_ref (data->stipple);
 212           data->values_mask |= GDK_GC_STIPPLE;
 213           GDK_NOTE (MISC, (g_print ("%sstipple=%#x", s,
 214                                     GDK_DRAWABLE_XID (data->stipple)),
 215                            s = ","));
 216         }
 217       else
 218         {
 219           data->values_mask &= ~GDK_GC_STIPPLE;
 220           GDK_NOTE (MISC, (g_print ("%sstipple=NULL", s),
 221                            s = ","));
 222         }
 223     }
 224
 225   if (mask & GDK_GC_CLIP_MASK)
 226     {
 227       if (data->clip_region != NULL)
 228         if (!DeleteObject (data->clip_region))
 229           WIN32_API_FAILED ("DeleteObject");
 230       if (values->clip_mask != NULL)
 231         {
 232           data->clip_region =
 233             BitmapToRegion ((HBITMAP) GDK_DRAWABLE_XID (values->clip_mask));
 234           data->values_mask |= GDK_GC_CLIP_MASK;
 235         }
 236       else
 237         {
 238           data->clip_region = NULL;
 239           data->values_mask &= ~GDK_GC_CLIP_MASK;
 240         }
 241       GDK_NOTE (MISC, (g_print ("%sclip=%#x", s, data->clip_region),
 242                        s = ","));
 243     }
 244
 245   if (mask & GDK_GC_SUBWINDOW)
 246     {
 247       data->subwindow_mode = values->subwindow_mode;
 248       data->values_mask |= GDK_GC_SUBWINDOW;
 249       GDK_NOTE (MISC, (g_print ("%ssubw=%d", s, data->subwindow_mode),
 250                        s = ","));
 251     }
 252
 253   if (mask & GDK_GC_TS_X_ORIGIN)
 254     {
 255       data->ts_x_origin = values->ts_x_origin;
 256       data->values_mask |= GDK_GC_TS_X_ORIGIN;
 257       GDK_NOTE (MISC, (g_print ("%sts_x=%d", s, data->ts_x_origin),
 258                        s = ","));
 259     }
 260
 261   if (mask & GDK_GC_TS_Y_ORIGIN)
 262     {
 263       data->ts_y_origin = values->ts_y_origin;
 264       data->values_mask |= GDK_GC_TS_Y_ORIGIN;
 265       GDK_NOTE (MISC, (g_print ("%sts_y=%d", s, data->ts_y_origin),
 266                        s = ","));
 267     }
 268
 269   if (mask & GDK_GC_CLIP_X_ORIGIN)
 270     {
 271       data->clip_x_origin = values->clip_x_origin;
 272       data->values_mask |= GDK_GC_CLIP_X_ORIGIN;
 273       GDK_NOTE (MISC, (g_print ("%sclip_x=%d", s, data->clip_x_origin),
 274                        s = ","));
 275     }
 276
 277   if (mask & GDK_GC_CLIP_Y_ORIGIN)
 278     {
 279       data->clip_y_origin = values->clip_y_origin;
 280       data->values_mask |= GDK_GC_CLIP_Y_ORIGIN;
 281       GDK_NOTE (MISC, (g_print ("%sclip_y=%d", s, data->clip_y_origin),
 282                        s = ","));
 283    }
 284
 285   if (mask & GDK_GC_EXPOSURES)
 286     {
 287       data->graphics_exposures = values->graphics_exposures;
 288       data->values_mask |= GDK_GC_EXPOSURES;
 289       GDK_NOTE (MISC, (g_print ("%sexp=%d", s, data->graphics_exposures),
 290                        s = ","));
 291     }
 292
 293   if (mask & GDK_GC_LINE_WIDTH)
 294     {
 295       data->pen_width = values->line_width;
 296       data->values_mask |= GDK_GC_LINE_WIDTH;
 297       GDK_NOTE (MISC, (g_print ("%spw=%d", s, data->pen_width),
 298                        s = ","));
 299     }
 300
 301   if (mask & GDK_GC_LINE_STYLE)
 302     {
 303       data->pen_style &= ~(PS_STYLE_MASK);
 304       GDK_NOTE (MISC, (g_print ("%sps|=", s),
 305                        s = ","));
 306       switch (values->line_style)
 307         {
 308         case GDK_LINE_SOLID:
 309           GDK_NOTE (MISC, g_print ("LINE_SOLID"));
 310           data->pen_style |= PS_SOLID;
 311           break;
 312         case GDK_LINE_ON_OFF_DASH:
 313         case GDK_LINE_DOUBLE_DASH: /* ??? */
 314           GDK_NOTE (MISC, g_print ("DASH"));
 315           data->pen_style |= PS_DASH;
 316           break;
 317         }
 318       data->values_mask |= GDK_GC_LINE_STYLE;
 319     }
 320
 321   if (mask & GDK_GC_CAP_STYLE)
 322     {
 323       data->pen_style &= ~(PS_ENDCAP_MASK);
 324       GDK_NOTE (MISC, (g_print ("%sps|=", s),
 325                        s = ","));
 326       switch (values->cap_style)
 327         {
 328         case GDK_CAP_NOT_LAST:  /* ??? */
 329         case GDK_CAP_BUTT:
 330           GDK_NOTE (MISC, g_print ("ENDCAP_FLAT"));
 331           data->pen_style |= PS_ENDCAP_FLAT;
 332           break;
 333         case GDK_CAP_ROUND:
 334           GDK_NOTE (MISC, g_print ("ENDCAP_ROUND"));
 335           data->pen_style |= PS_ENDCAP_ROUND;
 336           break;
 337         case GDK_CAP_PROJECTING:
 338           GDK_NOTE (MISC, g_print ("ENDCAP_SQUARE"));
 339           data->pen_style |= PS_ENDCAP_SQUARE;
 340           break;
 341         }
 342       data->values_mask |= GDK_GC_CAP_STYLE;
 343     }
 344
 345   if (mask & GDK_GC_JOIN_STYLE)
 346     {
 347       data->pen_style &= ~(PS_JOIN_MASK);
 348       GDK_NOTE (MISC, (g_print ("%sps|=", s),
 349                        s = ","));
 350       switch (values->join_style)
 351         {
 352         case GDK_JOIN_MITER:
 353           GDK_NOTE (MISC, g_print ("JOIN_MITER"));
 354           data->pen_style |= PS_JOIN_MITER;
 355           break;
 356         case GDK_JOIN_ROUND:
 357           GDK_NOTE (MISC, g_print ("JOIN_ROUND"));
 358           data->pen_style |= PS_JOIN_ROUND;
 359           break;
 360         case GDK_JOIN_BEVEL:
 361           GDK_NOTE (MISC, g_print ("JOIN_BEVEL"));
 362           data->pen_style |= PS_JOIN_BEVEL;
 363           break;
 364         }
 365       data->values_mask |= GDK_GC_JOIN_STYLE;
 366     }
 367   GDK_NOTE (MISC, g_print ("}\n"));
 368 }
 369
 370 GdkGC*
 371 _gdk_win32_gc_new (GdkDrawable    *drawable,
 372                    GdkGCValues    *values,
 373                    GdkGCValuesMask mask)
 374 {
 375   GdkGC *gc;
 376   GdkGCPrivate *private;
 377   GdkGCWin32Data *data;
 378   static GdkColor black;
 379   static GdkColor white;
 380   static gboolean beenhere = FALSE;
 381
 382   if (!beenhere)
 383     {
 384       gdk_color_black (gdk_colormap_get_system (), &black);
 385       gdk_color_white (gdk_colormap_get_system (), &white);
 386       beenhere = TRUE;
 387     }
 388
 389   gc = gdk_gc_alloc ();
 390   private = (GdkGCPrivate *)gc;
 391
 392   private->klass = &gdk_win32_gc_class;
 393   private->klass_data = data = g_new (GdkGCWin32Data, 1);
 394
 395   data->foreground = black.pixel;
 396   data->background = white.pixel;
 397   data->font = NULL;
 398   data->rop2 = R2_COPYPEN;
 399   data->fill_style = GDK_SOLID;
 400   data->tile = NULL;
 401   data->stipple = NULL;
 402   data->clip_region = NULL;
 403   data->ts_x_origin = data->ts_y_origin =
 404     data->clip_x_origin = data->clip_y_origin = 0;
 405   data->pen_style = PS_GEOMETRIC;
 406   data->pen_width = 1;
 407
 408   data->values_mask = GDK_GC_FUNCTION | GDK_GC_FILL;
 409
 410   GDK_NOTE (MISC, g_print ("_gdk_win32_gc_new: "));
 411   gdk_win32_gc_values_to_win32values (values, mask, data);
 412
 413   data->hwnd = NULL;
 414   data->xgc = NULL;
 415
 416   GDK_NOTE (MISC, g_print (" = %p\n", gc));
 417
 418   return gc;
 419 }
 420
 421 static void
 422 gdk_win32_gc_destroy (GdkGC *gc)
 423 {
 424   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
 425
 426   if (data->values_mask & GDK_GC_FONT)
 427     gdk_font_unref (data->font);
 428
 429   if (data->values_mask & GDK_GC_TILE)
 430     gdk_drawable_unref (data->tile);
 431
 432   if (data->values_mask & GDK_GC_STIPPLE)
 433     gdk_drawable_unref (data->stipple);
 434
 435   if (data->values_mask & GDK_GC_CLIP_MASK)
 436     DeleteObject (data->clip_region);
 437
 438   g_free (GDK_GC_WIN32DATA (gc));
 439 }
 440
 441 static void
 442 gdk_win32_gc_get_values (GdkGC       *gc,
 443                          GdkGCValues *values)
 444 {
 445   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
 446
 447   values->foreground.pixel = data->foreground;
 448   values->background.pixel = data->background;
 449   values->font = data->font;
 450
 451   switch (data->rop2)
 452     {
 453     case R2_COPYPEN:
 454       values->function = GDK_COPY; break;
 455     case R2_NOT:
 456       values->function = GDK_INVERT; break;
 457     case R2_XORPEN:
 458       values->function = GDK_XOR; break;
 459     case R2_BLACK:
 460       values->function = GDK_CLEAR; break;
 461     case R2_MASKPEN:
 462       values->function = GDK_AND; break;
 463     case R2_MASKPENNOT:
 464       values->function = GDK_AND_REVERSE; break;
 465     case R2_MASKNOTPEN:
 466       values->function = GDK_AND_INVERT; break;
 467     case R2_NOP:
 468       values->function = GDK_NOOP; break;
 469     case R2_MERGEPEN:
 470       values->function = GDK_OR; break;
 471     case R2_NOTXORPEN:
 472       values->function = GDK_EQUIV; break;
 473     case R2_MERGEPENNOT:
 474       values->function = GDK_OR_REVERSE; break;
 475     case R2_NOTCOPYPEN:
 476       values->function = GDK_COPY_INVERT; break;
 477     case R2_MERGENOTPEN:
 478       values->function = GDK_OR_INVERT; break;
 479     case R2_NOTMASKPEN:
 480       values->function = GDK_NAND; break;
 481     case R2_WHITE:
 482       values->function = GDK_SET; break;
 483     }
 484
 485   values->fill = data->fill_style;
 486
 487   values->tile = data->tile;
 488   values->stipple = data->stipple;
 489
 490   if (data->clip_region != NULL)
 491     {
 492       RECT rect;
 493       HBRUSH hbr;
 494       HDC hdc;
 495       HGDIOBJ oldbitmap;
 496       GdkPixmap *pixmap;
 497
 498       GetRgnBox (data->clip_region, &rect);
 499       pixmap =
 500         gdk_pixmap_new (NULL, rect.right - rect.left, rect.bottom - rect.top,
 501                         1);
 502       hbr = GetStockObject (WHITE_BRUSH);
 503       if ((hdc = CreateCompatibleDC (NULL)) == NULL)
 504         WIN32_API_FAILED ("CreateCompatibleDC");
 505       if ((oldbitmap =
 506            SelectObject (hdc, GDK_DRAWABLE_XID (pixmap))) == NULL)
 507         WIN32_API_FAILED ("SelectObject #1");
 508       hbr = GetStockObject (BLACK_BRUSH);
 509       if (!FillRect (hdc, &rect, hbr))
 510         WIN32_API_FAILED ("FillRect");
 511       hbr = GetStockObject (WHITE_BRUSH);
 512       if (!FillRgn (hdc, data->clip_region, hbr))
 513         WIN32_API_FAILED ("FillRgn");
 514       if (SelectObject (hdc, oldbitmap) == NULL)
 515         WIN32_API_FAILED ("SelectObject #2");
 516       DeleteDC (hdc);
 517       values->clip_mask = pixmap;
 518     }
 519   else
 520     values->clip_mask = NULL;
 521   values->subwindow_mode = data->subwindow_mode;
 522   values->ts_x_origin = data->ts_x_origin;
 523   values->ts_y_origin = data->ts_y_origin;
 524   values->clip_x_origin = data->clip_x_origin;
 525   values->clip_y_origin = data->clip_y_origin;
 526   values->graphics_exposures = data->graphics_exposures;
 527   values->line_width = data->pen_width;
 528
 529   if (data->pen_style & PS_SOLID)
 530     values->line_style = GDK_LINE_SOLID;
 531   else if (data->pen_style & PS_DASH)
 532     values->line_style = GDK_LINE_ON_OFF_DASH;
 533   else
 534     values->line_style = GDK_LINE_SOLID;
 535
 536   /* PS_ENDCAP_ROUND is zero */
 537   if (data->pen_style & PS_ENDCAP_FLAT)
 538     values->cap_style = GDK_CAP_BUTT;
 539   else if (data->pen_style & PS_ENDCAP_SQUARE)
 540     values->cap_style = GDK_CAP_PROJECTING;
 541   else
 542     values->cap_style = GDK_CAP_ROUND;
 543
 544   /* PS_JOIN_ROUND is zero */
 545   if (data->pen_style & PS_JOIN_MITER)
 546     values->join_style = GDK_JOIN_MITER;
 547   else if (data->pen_style & PS_JOIN_BEVEL)
 548     values->join_style = GDK_JOIN_BEVEL;
 549   else
 550     values->join_style = GDK_JOIN_ROUND;
 551 }
 552
 553 static void
 554 gdk_win32_gc_set_values (GdkGC           *gc,
 555                          GdkGCValues     *values,
 556                          GdkGCValuesMask  mask)
 557 {
 558   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
 559
 560   GDK_NOTE (MISC, g_print ("gdk_win32_gc_set_values: "));
 561
 562   gdk_win32_gc_values_to_win32values (values, mask, data);
 563 }
 564
 565 static void
 566 gdk_win32_gc_set_dashes (GdkGC *gc,
 567                          gint     dash_offset,
 568                          gchar  dash_list[],
 569                          gint   n)
 570 {
 571   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
 572
 573   /* XXX ??? */
 574
 575   data->pen_style &= ~(PS_STYLE_MASK);
 576   data->pen_style |= PS_DASH;
 577 }
 578
 579 void
 580 gdk_gc_set_clip_rectangle (GdkGC        *gc,
 581                            GdkRectangle *rectangle)
 582 {
 583   GdkGCWin32Data *data;
 584
 585   g_return_if_fail (gc != NULL);
 586
 587   data = GDK_GC_WIN32DATA (gc);
 588
 589   if (data->clip_region != NULL)
 590     if (!DeleteObject (data->clip_region))
 591       WIN32_API_FAILED ("DeleteObject");
 592   if (rectangle)
 593     {
 594       GDK_NOTE (MISC,
 595                 g_print ("gdk_gc_set_clip_rectangle: (%d) %dx%d@+%d+%d\n",
 596                          data,
 597                          rectangle->width, rectangle->height,
 598                          rectangle->x, rectangle->y));
 599       if ((data->clip_region =
 600            CreateRectRgn (rectangle->x, rectangle->y,
 601                           rectangle->x + rectangle->width,
 602                           rectangle->y + rectangle->height)) == NULL)
 603         WIN32_API_FAILED ("CreateRectRgn");
 604
 605       data->values_mask |= GDK_GC_CLIP_MASK;
 606     }
 607   else
 608     {
 609       GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_rectangle: (%d) NULL\n",
 610                                data));
 611       data->clip_region = NULL;
 612       data->values_mask &= ~GDK_GC_CLIP_MASK;
 613     }
 614     data->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
 615 }
 616
 617 void
 618 gdk_gc_set_clip_region (GdkGC            *gc,
 619                         GdkRegion        *region)
 620 {
 621   GdkGCWin32Data *data;
 622
 623   g_return_if_fail (gc != NULL);
 624
 625   data = GDK_GC_WIN32DATA (gc);
 626
 627   GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_region: (%d) %s\n",
 628                            data, (region != NULL ? "xxx" : "None")));
 629
 630   if (data->clip_region != NULL)
 631     if (!DeleteObject (data->clip_region))
 632       WIN32_API_FAILED ("DeleteObject");
 633   if (region)
 634     {
 635       GdkRegionPrivate *region_private;
 636
 637       region_private = (GdkRegionPrivate*) region;
 638       data->clip_region = CreateRectRgn (1, 1, 0, 0);
 639       CombineRgn (data->clip_region, region_private->xregion, NULL, RGN_COPY);
 640       data->values_mask |= GDK_GC_CLIP_MASK;
 641     }
 642   else
 643     {
 644       data->clip_region = NULL;
 645       data->values_mask &= ~GDK_GC_CLIP_MASK;
 646     }
 647 }
 648
 649 void
 650 gdk_gc_copy (GdkGC *dst_gc, GdkGC *src_gc)
 651 {
 652   GdkGCWin32Data *dst_data = GDK_GC_WIN32DATA (dst_gc);
 653   GdkGCWin32Data *src_data = GDK_GC_WIN32DATA (src_gc);
 654   DWORD nbytes;
 655   LPRGNDATA rgn;
 656
 657   if (dst_data->font != NULL)
 658     gdk_font_unref (dst_data->font);
 659   if (dst_data->tile != NULL)
 660     gdk_drawable_unref (dst_data->tile);
 661   if (dst_data->stipple != NULL)
 662     gdk_drawable_unref (dst_data->stipple);
 663   if (dst_data->clip_region != NULL)
 664     if (!DeleteObject (dst_data->clip_region))
 665       WIN32_API_FAILED ("DeleteObject");
 666
 667   *dst_data = *src_data;
 668
 669   if (dst_data->clip_region != NULL)
 670     {
 671       nbytes = GetRegionData (dst_data->clip_region, 0, NULL);
 672       rgn = g_malloc (nbytes);
 673       GetRegionData (dst_data->clip_region, nbytes, rgn);
 674       if ((dst_data->clip_region = ExtCreateRegion (NULL, nbytes, rgn)) == NULL)
 675         WIN32_API_FAILED ("ExtCreateRegion");
 676       g_free (rgn);
 677     }
 678
 679   if (dst_data->font != NULL)
 680     gdk_font_ref (dst_data->font);
 681   if (dst_data->tile != NULL)
 682     gdk_drawable_ref (dst_data->tile);
 683   if (dst_data->stipple != NULL)
 684     gdk_drawable_ref (dst_data->stipple);
 685 }
 686
 687 static guint mask[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
 688
 689 static void
 690 predraw_set_foreground (GdkGCWin32Data          *data,
 691                         GdkColormapPrivateWin32 *colormap_private)
 692 {
 693   COLORREF fg;
 694   LOGBRUSH logbrush;
 695   HPEN hpen;
 696   HBRUSH hbr;
 697   GdkVisual *visual;
 698   guchar r, g, b;
 699
 700   if (colormap_private == NULL)
 701     {
 702       /* A 1 bit deep bitmap */
 703       struct
 704       {
 705         WORD palVersion;
 706         WORD palNumEntries;
 707         PALETTEENTRY palPalEntry[2];
 708       } logpal;
 709       static HPALETTE hpal = NULL;
 710
 711       if (hpal == NULL)
 712         {
 713           /* Create a b&w palette */
 714           logpal.palVersion = 0x300;
 715           logpal.palNumEntries = 2;
 716           logpal.palPalEntry[0].peRed =
 717             logpal.palPalEntry[0].peGreen =
 718             logpal.palPalEntry[0].peBlue = 0x00;
 719           logpal.palPalEntry[0].peFlags = 0x00;
 720           logpal.palPalEntry[1].peRed =
 721             logpal.palPalEntry[1].peGreen =
 722             logpal.palPalEntry[1].peBlue = 0xFF;
 723           logpal.palPalEntry[1].peFlags = 0x00;
 724           if ((hpal = CreatePalette ((LOGPALETTE *) &logpal)) == NULL)
 725             WIN32_API_FAILED ("CreatePalette");
 726         }
 727       SelectPalette (data->xgc, hpal, FALSE);
 728       RealizePalette (data->xgc);
 729       fg = PALETTEINDEX (data->foreground);
 730     }
 731   else if (colormap_private->xcolormap->rc_palette)
 732     {
 733       int k;
 734       if (SelectPalette (data->xgc, colormap_private->xcolormap->palette,
 735                          FALSE) == NULL)
 736         WIN32_API_FAILED ("SelectPalette");
 737       if (TRUE || colormap_private->xcolormap->stale)
 738         {
 739           if ((k = RealizePalette (data->xgc)) == GDI_ERROR)
 740             WIN32_API_FAILED ("RealizePalette");
 741           colormap_private->xcolormap->stale = FALSE;
 742         }
 743 #if 0
 744       g_print ("Selected palette %#x for gc %#x, realized %d colors\n",
 745                colormap_private->xcolormap->palette, data->xgc, k);
 746 #endif
 747       fg = PALETTEINDEX (data->foreground);
 748     }
 749   else
 750     {
 751       visual = colormap_private->base.visual;
 752       r = (data->foreground & visual->red_mask) >> visual->red_shift;
 753       r = (r * 255) / mask[visual->red_prec];
 754       g = (data->foreground & visual->green_mask) >> visual->green_shift;
 755       g = (g * 255) / mask[visual->green_prec];
 756       b = (data->foreground & visual->blue_mask) >> visual->blue_shift;
 757       b = (b * 255) / mask[visual->blue_prec];
 758
 759       fg = GetNearestColor (data->xgc, RGB (r, g, b));
 760     }
 761
 762   if (SetTextColor (data->xgc, fg) == CLR_INVALID)
 763     WIN32_API_FAILED ("SetTextColor");
 764
 765   /* Create and select pen and brush. */
 766
 767   logbrush.lbStyle = BS_SOLID;
 768   logbrush.lbColor = fg;
 769
 770   if ((hpen = ExtCreatePen (data->pen_style, data->pen_width,
 771                             &logbrush, 0, NULL)) == NULL)
 772     WIN32_API_FAILED ("ExtCreatePen");
 773
 774   if (SelectObject (data->xgc, hpen) == NULL)
 775     WIN32_API_FAILED ("SelectObject #2");
 776
 777   switch (data->fill_style)
 778     {
 779 #if 1
 780     case GDK_OPAQUE_STIPPLED:
 781       if ((hbr = CreatePatternBrush (GDK_DRAWABLE_XID (data->stipple))) == NULL)
 782         WIN32_API_FAILED ("CreatePatternBrush");
 783
 784       SetBrushOrgEx(data->xgc, data->ts_x_origin,
 785                     data->ts_y_origin, NULL);
 786       break;
 787 #endif
 788
 789     case GDK_SOLID:
 790     default:
 791       if ((hbr = CreateSolidBrush (fg)) == NULL)
 792         WIN32_API_FAILED ("CreateSolidBrush");
 793       break;
 794   }
 795
 796   if (SelectObject (data->xgc, hbr) == NULL)
 797     WIN32_API_FAILED ("SelectObject #3");
 798 }
 799
 800 void
 801 predraw_set_background (GdkGCWin32Data          *data,
 802                         GdkColormapPrivateWin32 *colormap_private)
 803 {
 804   COLORREF bg;
 805   GdkVisual *visual;
 806   guchar r, g, b;
 807
 808   if (colormap_private == NULL)
 809     {
 810       /* a bitmap */
 811       bg = PALETTEINDEX (data->background);
 812     }
 813   else if (colormap_private->xcolormap->rc_palette)
 814     {
 815       bg = PALETTEINDEX (data->background);
 816     }
 817   else
 818     {
 819       visual = colormap_private->base.visual;
 820       r = (data->background & visual->red_mask) >> visual->red_shift;
 821       r = (r * 255) / mask[visual->red_prec];
 822       g = (data->background & visual->green_mask) >> visual->green_shift;
 823       g = (g * 255) / mask[visual->green_prec];
 824       b = (data->background & visual->blue_mask) >> visual->blue_shift;
 825       b = (b * 255) / mask[visual->green_prec];
 826
 827       bg = GetNearestColor (data->xgc, RGB (r, g, b));
 828     }
 829   if (SetBkColor (data->xgc, bg) == CLR_INVALID)
 830     WIN32_API_FAILED ("SetBkColor");
 831 }
 832
 833
 834 HDC
 835 gdk_gc_predraw (GdkDrawable    *drawable,
 836                 GdkGCPrivate   *gc_private,
 837                 GdkGCValuesMask usage)
 838 {
 839   GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
 840   GdkColormapPrivateWin32 *colormap_private =
 841     (GdkColormapPrivateWin32 *) drawable_private->colormap;
 842   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
 843
 844   g_assert (data->xgc == NULL);
 845
 846   data->hwnd = GDK_DRAWABLE_XID (drawable);
 847
 848   if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
 849     {
 850       if ((data->xgc = CreateCompatibleDC (NULL)) == NULL)
 851         WIN32_API_FAILED ("CreateCompatibleDC");
 852
 853       if ((data->saved_dc = SaveDC (data->xgc)) == 0)
 854         WIN32_API_FAILED ("SaveDC #1");
 855
 856       if (SelectObject (data->xgc, data->hwnd) == NULL)
 857         WIN32_API_FAILED ("SelectObject #1");
 858     }
 859   else
 860     {
 861       if ((data->xgc = GetDC (data->hwnd)) == NULL)
 862         WIN32_API_FAILED ("GetDC");
 863
 864       if ((data->saved_dc = SaveDC (data->xgc)) == 0)
 865         WIN32_API_FAILED ("SaveDC #2");
 866     }
 867
 868   if (usage & GDK_GC_FOREGROUND)
 869     predraw_set_foreground (data, colormap_private);
 870
 871   if ((usage & GDK_GC_BACKGROUND) && (data->values_mask & GDK_GC_BACKGROUND))
 872     predraw_set_background (data, colormap_private);
 873
 874   if (usage & GDK_GC_FONT)
 875     {
 876       if (SetBkMode (data->xgc, TRANSPARENT) == 0)
 877         WIN32_API_FAILED ("SetBkMode");
 878
 879       if (SetTextAlign (data->xgc, TA_BASELINE) == GDI_ERROR)
 880         WIN32_API_FAILED ("SetTextAlign");
 881     }
 882
 883   if (data->values_mask & GDK_GC_FUNCTION)
 884     if (SetROP2 (data->xgc, data->rop2) == 0)
 885       WIN32_API_FAILED ("SetROP2");
 886
 887   if (data->values_mask & GDK_GC_CLIP_MASK
 888       && data->clip_region != NULL)
 889     {
 890       if (data->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
 891         OffsetRgn (data->clip_region,
 892                    data->clip_x_origin, data->clip_y_origin);
 893       SelectClipRgn (data->xgc, data->clip_region);
 894     }
 895
 896   return data->xgc;
 897 }
 898
 899 void
 900 gdk_gc_postdraw (GdkDrawable    *drawable,
 901                  GdkGCPrivate   *gc_private,
 902                  GdkGCValuesMask usage)
 903 {
 904   GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
 905   GdkColormapPrivateWin32 *colormap_private =
 906     (GdkColormapPrivateWin32 *) drawable_private->colormap;
 907   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
 908   HGDIOBJ hpen = NULL;
 909   HGDIOBJ hbr = NULL;
 910
 911   if (usage & GDK_GC_FOREGROUND)
 912     {
 913       if ((hpen = GetCurrentObject (data->xgc, OBJ_PEN)) == NULL)
 914         WIN32_API_FAILED ("GetCurrentObject #1");
 915
 916       if ((hbr = GetCurrentObject (data->xgc, OBJ_BRUSH)) == NULL)
 917         WIN32_API_FAILED ("GetCurrentObject #2");
 918     }
 919
 920   if (!RestoreDC (data->xgc, data->saved_dc))
 921     WIN32_API_FAILED ("RestoreDC");
 922 #if 0
 923   if (colormap_private != NULL
 924       && colormap_private->xcolormap->rc_palette
 925       && colormap_private->xcolormap->stale)
 926     {
 927       SelectPalette (data->xgc, GetStockObject (DEFAULT_PALETTE), FALSE);
 928       if (!UnrealizeObject (colormap_private->xcolormap->palette))
 929         WIN32_API_FAILED ("UnrealizeObject");
 930     }
 931 #endif
 932   if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
 933     {
 934       if (!DeleteDC (data->xgc))
 935         WIN32_API_FAILED ("DeleteDC");
 936     }
 937   else
 938     {
 939       ReleaseDC (data->hwnd, data->xgc);
 940     }
 941
 942   if (hpen != NULL)
 943     if (!DeleteObject (hpen))
 944       WIN32_API_FAILED ("DeleteObject #1");
 945
 946   if (hbr != NULL)
 947     if (!DeleteObject (hbr))
 948       WIN32_API_FAILED ("DeleteObject #2");
 949
 950   if (data->values_mask & GDK_GC_CLIP_MASK
 951       && data->clip_region != NULL
 952       && (data->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN)))
 953     OffsetRgn (data->clip_region,
 954                -data->clip_x_origin, -data->clip_y_origin);
 955   data->xgc = NULL;
 956 }
 957
 958 /* This function originally from Jean-Edouard Lachand-Robert, and
 959  * available at www.codeguru.com. Simplified for our needs, now
 960  * handles just one-bit deep bitmaps (in Window parlance, ie those
 961  * that GDK calls bitmaps (and not pixmaps), with zero pixels being
 962  * transparent.
 963  */
 964
 965 /*
 966  *  BitmapToRegion :  Create a region from the "non-transparent" pixels of
 967  *  a bitmap
 968  *  Author :      Jean-Edouard Lachand-Robert
 969  *  (http://www.geocities.com/Paris/LeftBank/1160/resume.htm), June 1998.
 970  */
 971
 972 HRGN
 973 BitmapToRegion (HBITMAP hBmp)
 974 {
 975   HRGN hRgn = NULL;
 976   HDC hMemDC;
 977   BITMAP bm;
 978
 979   struct
 980   {
 981     BITMAPINFOHEADER bmiHeader;
 982 #if 1
 983     WORD bmiColors[2];
 984 #else
 985     RGBQUAD bmiColors[2];
 986 #endif
 987   } bmi;
 988   VOID *pbits8;
 989   HBITMAP hbm8;
 990   struct
 991   {
 992     WORD palVersion;
 993     WORD palNumEntries;
 994     PALETTEENTRY palPalEntry[2];
 995   } logpal;
 996   static HPALETTE bwPalette = NULL;
 997
 998   HBITMAP holdBmp;
 999   HDC hDC;
1000
1001   BITMAP bm8;
1002   HBITMAP holdBmp2;
1003   DWORD maxRects;
1004   RGNDATA *pData;
1005   BYTE *p8;
1006   int x, y;
1007   HRGN h;
1008
1009   /* Create a B&W palette */
1010   if (bwPalette == NULL)
1011     {
1012       /* Create a b&w palette */
1013       logpal.palVersion = 0x300;
1014       logpal.palNumEntries = 2;
1015       logpal.palPalEntry[0].peRed =
1016         logpal.palPalEntry[0].peGreen =
1017         logpal.palPalEntry[0].peBlue = 0;
1018       logpal.palPalEntry[0].peFlags = 0;
1019       logpal.palPalEntry[1].peRed =
1020         logpal.palPalEntry[1].peGreen =
1021         logpal.palPalEntry[1].peBlue = 0xFF;
1022       logpal.palPalEntry[1].peFlags = 0;
1023       if ((bwPalette = CreatePalette ((LOGPALETTE *) &logpal)) == NULL)
1024         WIN32_API_FAILED ("CreatePalette");
1025     }
1026
1027   /* Create a memory DC inside which we will scan the bitmap content */
1028   hMemDC = CreateCompatibleDC (NULL);
1029   if (!hMemDC)
1030     {
1031       WIN32_API_FAILED ("CreateCompatibleDC #1");
1032       return NULL;
1033     }
1034
1035   SelectPalette (hMemDC, bwPalette, FALSE);
1036   RealizePalette (hMemDC);
1037
1038   /* Get bitmap size */
1039   GetObject(hBmp, sizeof(bm), &bm);
1040
1041   /* Create a 8 bits depth bitmap and select it into the memory DC */
1042   bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
1043   bmi.bmiHeader.biWidth = bm.bmWidth;
1044   bmi.bmiHeader.biHeight = bm.bmHeight;
1045   bmi.bmiHeader.biPlanes = 1;
1046   bmi.bmiHeader.biBitCount = 8;
1047   bmi.bmiHeader.biCompression = BI_RGB;
1048   bmi.bmiHeader.biSizeImage = 0;
1049   bmi.bmiHeader.biXPelsPerMeter = 0;
1050   bmi.bmiHeader.biYPelsPerMeter = 0;
1051   bmi.bmiHeader.biClrUsed = 2;
1052   bmi.bmiHeader.biClrImportant = 2;
1053 #if 1
1054   bmi.bmiColors[0] = 0;
1055   bmi.bmiColors[1] = 1;
1056   hbm8 = CreateDIBSection (hMemDC, (BITMAPINFO *)&bmi,
1057                             DIB_PAL_COLORS, &pbits8, NULL, 0);
1058 #else
1059   bmi.bmiColors[0].rgbBlue =
1060     bmi.bmiColors[0].rgbGreen =
1061     bmi.bmiColors[0].rgbRed = 0x00;
1062   bmi.bmiColors[0].rgbReserved = 0x00;
1063
1064   bmi.bmiColors[1].rgbBlue =
1065     bmi.bmiColors[1].rgbGreen =
1066     bmi.bmiColors[1].rgbRed = 0xFF;
1067   bmi.bmiColors[0].rgbReserved = 0x00;
1068
1069   hbm8 = CreateDIBSection (hMemDC, (BITMAPINFO *)&bmi,
1070                             DIB_RGB_COLORS, &pbits8, NULL, 0);
1071 #endif
1072   if (!hbm8)
1073     {
1074       WIN32_API_FAILED ("CreateDIBSection");
1075       DeleteDC (hMemDC);
1076       return NULL;
1077     }
1078
1079   holdBmp = (HBITMAP) SelectObject (hMemDC, hbm8);
1080
1081   /* Create a DC just to copy the bitmap into the memory DC*/
1082   hDC = CreateCompatibleDC (hMemDC);
1083   if (!hDC)
1084     {
1085       WIN32_API_FAILED ("CreateCompatibleDC #2");
1086       SelectObject (hMemDC, holdBmp);
1087       DeleteObject (hbm8);
1088       DeleteDC (hMemDC);
1089       return NULL;
1090     }
1091
1092   /* Get how many bytes per row we have for the bitmap bits */
1093   GetObject (hbm8, sizeof (bm8), &bm8);
1094
1095   /* Hans Breuer found a fix to the long-standing erroneous behaviour
1096    * on NT 4.0: There seems to be a bug in Win NT 4.0 GDI: scanlines
1097    * in bitmaps are dword aligned on both Win95 and NT. In the case of
1098    * a bitmap with 22 bytes worth of width, GetObject above returns
1099    * with bmWidth == 22. On Win95 bmWidthBytes == 24, as it should be,
1100    * but on NT is it 22. We need to correct this here.
1101    */
1102   bm8.bmWidthBytes = (((bm8.bmWidthBytes-1)/4)+1)*4; /* dword aligned!! */
1103
1104   /* Copy the bitmap into the memory DC*/
1105   holdBmp2 = (HBITMAP) SelectObject (hDC, hBmp);
1106
1107   if (!BitBlt (hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY))
1108     {
1109       WIN32_API_FAILED ("BitBlt");
1110       SelectObject (hDC, holdBmp2);
1111       SelectObject (hMemDC, holdBmp);
1112       DeleteObject (hbm8);
1113       DeleteDC (hMemDC);
1114       return NULL;
1115     }
1116   SelectObject (hDC, holdBmp2);
1117   DeleteDC (hDC);
1118
1119   /* For better performances, we will use the ExtCreateRegion()
1120    * function to create the region. This function take a RGNDATA
1121    * structure on entry. We will add rectangles by amount of
1122    * ALLOC_UNIT number in this structure.
1123    */
1124   #define ALLOC_UNIT  100
1125   maxRects = ALLOC_UNIT;
1126
1127   pData = g_malloc (sizeof (RGNDATAHEADER) + (sizeof (RECT) * maxRects));
1128   pData->rdh.dwSize = sizeof (RGNDATAHEADER);
1129   pData->rdh.iType = RDH_RECTANGLES;
1130   pData->rdh.nCount = pData->rdh.nRgnSize = 0;
1131   SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1132
1133   /* Scan each bitmap from bottom to top (the bitmap is inverted vertically)*/
1134   p8 = (BYTE *) pbits8 + (bm8.bmHeight - 1) * bm8.bmWidthBytes;
1135   for (y = 0; y < bm.bmHeight; y++)
1136     {
1137       /* Scan each bitmap row from left to right*/
1138       for (x = 0; x < bm.bmWidth; x++)
1139         {
1140           /* Search for a continuous range of "non transparent pixels"*/
1141           int x0 = x;
1142           BYTE *p = p8 + x;
1143           while (x < bm.bmWidth)
1144             {
1145               if (*p == 0)
1146                 /* This pixel is "transparent"*/
1147                 break;
1148               p++;
1149               x++;
1150             }
1151
1152           if (x > x0)
1153             {
1154               RECT *pr;
1155               /* Add the pixels (x0, y) to (x, y+1) as a new rectangle
1156                * in the region
1157                */
1158               if (pData->rdh.nCount >= maxRects)
1159                 {
1160                   maxRects += ALLOC_UNIT;
1161                   pData = g_realloc (pData, sizeof(RGNDATAHEADER)
1162                                      + (sizeof(RECT) * maxRects));
1163                 }
1164               pr = (RECT *) &pData->Buffer;
1165               SetRect (&pr[pData->rdh.nCount], x0, y, x, y+1);
1166               if (x0 < pData->rdh.rcBound.left)
1167                 pData->rdh.rcBound.left = x0;
1168               if (y < pData->rdh.rcBound.top)
1169                 pData->rdh.rcBound.top = y;
1170               if (x > pData->rdh.rcBound.right)
1171                 pData->rdh.rcBound.right = x;
1172               if (y+1 > pData->rdh.rcBound.bottom)
1173                 pData->rdh.rcBound.bottom = y+1;
1174               pData->rdh.nCount++;
1175
1176               /* On Windows98, ExtCreateRegion() may fail if the
1177                * number of rectangles is too large (ie: >
1178                * 4000). Therefore, we have to create the region by
1179                * multiple steps.
1180                */
1181               if (pData->rdh.nCount == 2000)
1182                 {
1183                   HRGN h = ExtCreateRegion (NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
1184                   if (hRgn)
1185                     {
1186                       CombineRgn(hRgn, hRgn, h, RGN_OR);
1187                       DeleteObject(h);
1188                     }
1189                   else
1190                     hRgn = h;
1191                   pData->rdh.nCount = 0;
1192                   SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1193                 }
1194             }
1195         }
1196
1197       /* Go to next row (remember, the bitmap is inverted vertically)*/
1198       p8 -= bm8.bmWidthBytes;
1199     }
1200
1201   /* Create or extend the region with the remaining rectangles*/
1202   h = ExtCreateRegion (NULL, sizeof (RGNDATAHEADER)
1203                        + (sizeof (RECT) * maxRects), pData);
1204   if (hRgn)
1205     {
1206       CombineRgn (hRgn, hRgn, h, RGN_OR);
1207       DeleteObject (h);
1208     }
1209   else
1210     hRgn = h;
1211
1212   /* Clean up*/
1213   SelectObject(hMemDC, holdBmp);
1214   DeleteObject (hbm8);
1215   DeleteDC (hMemDC);
1216
1217   return hRgn;
1218 }