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