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_GDI_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_GDI_FAILED ("CreateCompatibleDC");
 535       if ((oldbitmap =
 536            SelectObject (hdc, GDK_DRAWABLE_XID (pixmap))) == NULL)
 537         WIN32_GDI_FAILED ("SelectObject");
 538       hbr = GetStockObject (BLACK_BRUSH);
 539       if (!FillRect (hdc, &rect, hbr))
 540         WIN32_GDI_FAILED ("FillRect");
 541       hbr = GetStockObject (WHITE_BRUSH);
 542       if (!FillRgn (hdc, data->clip_region, hbr))
 543         WIN32_GDI_FAILED ("FillRgn");
 544       if (SelectObject (hdc, oldbitmap) == NULL)
 545         WIN32_GDI_FAILED ("SelectObject");
 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   data->pen_style &= ~(PS_STYLE_MASK);
 604   data->pen_style |= PS_DASH;
 605
 606   /*
 607    * Set the extended line style. This could be done by
 608    * PS_USERSTYLE and ExtCreatePen; but ONLY on WinNT,
 609    * so let's make a guess (based on the implementation
 610    * in DIA). On Win9x this does only work for lines
 611    * with width one ...
 612    *
 613    * More workarounds for Win9x descibed at:
 614    * http://www.codeguru.com/gdi/dashed.shtml
 615    */
 616   if (!IS_WIN_NT (windows_version) && data->pen_width > 1)
 617     {
 618       GDK_NOTE (MISC, g_print ("gdk_win32_gc_set_dashes: not fully supported\n"));
 619       data->pen_style |= PS_SOLID;
 620       return;
 621     }
 622
 623   /* data->pen_style = PS_COSMETIC; ??? */
 624   if (2 == n)
 625     {
 626       if ((dash_list[0] == dash_list[1]) && (dash_list[0] > 2))
 627         {
 628           data->pen_style |= PS_DASH;
 629           GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DASH (%d,%d)\n",
 630                                   dash_list[0], dash_list[1]));
 631         }
 632       else
 633         {
 634           data->pen_style |= PS_DOT;
 635           GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DOT (%d,%d)\n",
 636                                   dash_list[0], dash_list[1]));
 637         }
 638     }
 639   else if (4 == n)
 640     {
 641       data->pen_style |= PS_DASHDOT;
 642       GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DASHDOT (%d,%d,%d,%d)\n",
 643                               dash_list[0], dash_list[1],
 644                               dash_list[2], dash_list[3]));
 645     }
 646   else if (6 == n)
 647     {
 648       data->pen_style |= PS_DASHDOTDOT;
 649       GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: PS_DASHDOTDOT (%d,%d,%d,%d,%d,%d)\n",
 650                               dash_list[0], dash_list[1],
 651                               dash_list[2], dash_list[3],
 652                               dash_list[4], dash_list[5]));
 653     }
 654   else
 655     {
 656       data->pen_style |= PS_DASH;
 657       GDK_NOTE (MISC, g_print("gdk_win32_gc_set_dashes: no guess for %d dashes\n", n));
 658     }
 659 }
 660
 661 void
 662 gdk_gc_set_clip_rectangle (GdkGC        *gc,
 663                            GdkRectangle *rectangle)
 664 {
 665   GdkGCWin32Data *data;
 666
 667   g_return_if_fail (gc != NULL);
 668
 669   data = GDK_GC_WIN32DATA (gc);
 670
 671   if (data->clip_region != NULL)
 672     if (!DeleteObject (data->clip_region))
 673       WIN32_GDI_FAILED ("DeleteObject");
 674   if (rectangle)
 675     {
 676       GDK_NOTE (MISC,
 677                 g_print ("gdk_gc_set_clip_rectangle: (%d) %dx%d@+%d+%d\n",
 678                          data,
 679                          rectangle->width, rectangle->height,
 680                          rectangle->x, rectangle->y));
 681       if ((data->clip_region =
 682            CreateRectRgn (rectangle->x, rectangle->y,
 683                           rectangle->x + rectangle->width,
 684                           rectangle->y + rectangle->height)) == NULL)
 685         WIN32_GDI_FAILED ("CreateRectRgn");
 686
 687       data->values_mask |= GDK_GC_CLIP_MASK;
 688     }
 689   else
 690     {
 691       GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_rectangle: (%d) NULL\n",
 692                                data));
 693       data->clip_region = NULL;
 694       data->values_mask &= ~GDK_GC_CLIP_MASK;
 695     }
 696     data->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
 697 }
 698
 699 void
 700 gdk_gc_set_clip_region (GdkGC            *gc,
 701                         GdkRegion        *region)
 702 {
 703   GdkGCWin32Data *data;
 704
 705   g_return_if_fail (gc != NULL);
 706
 707   data = GDK_GC_WIN32DATA (gc);
 708
 709   GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_region: (%d) %s\n",
 710                            data, (region != NULL ? "xxx" : "None")));
 711
 712   if (data->clip_region != NULL)
 713     if (!DeleteObject (data->clip_region))
 714       WIN32_GDI_FAILED ("DeleteObject");
 715   if (region)
 716     {
 717       GdkRegionPrivate *region_private;
 718
 719       region_private = (GdkRegionPrivate*) region;
 720       data->clip_region = CreateRectRgn (1, 1, 0, 0);
 721       CombineRgn (data->clip_region, region_private->xregion, NULL, RGN_COPY);
 722       data->values_mask |= GDK_GC_CLIP_MASK;
 723     }
 724   else
 725     {
 726       data->clip_region = NULL;
 727       data->values_mask &= ~GDK_GC_CLIP_MASK;
 728     }
 729 }
 730
 731 void
 732 gdk_gc_copy (GdkGC *dst_gc, GdkGC *src_gc)
 733 {
 734   GdkGCWin32Data *dst_data = GDK_GC_WIN32DATA (dst_gc);
 735   GdkGCWin32Data *src_data = GDK_GC_WIN32DATA (src_gc);
 736   DWORD nbytes;
 737   LPRGNDATA rgn;
 738
 739   if (dst_data->font != NULL)
 740     gdk_font_unref (dst_data->font);
 741   if (dst_data->tile != NULL)
 742     gdk_drawable_unref (dst_data->tile);
 743   if (dst_data->stipple != NULL)
 744     gdk_drawable_unref (dst_data->stipple);
 745   if (dst_data->clip_region != NULL)
 746     if (!DeleteObject (dst_data->clip_region))
 747       WIN32_GDI_FAILED ("DeleteObject");
 748
 749   *dst_data = *src_data;
 750
 751   if (dst_data->clip_region != NULL)
 752     {
 753       nbytes = GetRegionData (dst_data->clip_region, 0, NULL);
 754       rgn = g_malloc (nbytes);
 755       GetRegionData (dst_data->clip_region, nbytes, rgn);
 756       if ((dst_data->clip_region = ExtCreateRegion (NULL, nbytes, rgn)) == NULL)
 757         WIN32_GDI_FAILED ("ExtCreateRegion");
 758       g_free (rgn);
 759     }
 760
 761   if (dst_data->font != NULL)
 762     gdk_font_ref (dst_data->font);
 763   if (dst_data->tile != NULL)
 764     gdk_drawable_ref (dst_data->tile);
 765   if (dst_data->stipple != NULL)
 766     gdk_drawable_ref (dst_data->stipple);
 767 }
 768
 769 static guint bitmask[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
 770
 771 COLORREF
 772 gdk_colormap_color (GdkColormapPrivateWin32 *colormap_private,
 773                     gulong                   pixel)
 774 {
 775   GdkVisual *visual;
 776   guchar r, g, b;
 777
 778   if (colormap_private == NULL || colormap_private->xcolormap->rc_palette)
 779     return PALETTEINDEX (pixel);
 780   else
 781     {
 782       visual = colormap_private->base.visual;
 783       r = (pixel & visual->red_mask) >> visual->red_shift;
 784       r = (r * 255) / bitmask[visual->red_prec];
 785       g = (pixel & visual->green_mask) >> visual->green_shift;
 786       g = (g * 255) / bitmask[visual->green_prec];
 787       b = (pixel & visual->blue_mask) >> visual->blue_shift;
 788       b = (b * 255) / bitmask[visual->blue_prec];
 789
 790       return RGB (r, g, b);
 791     }
 792 }
 793
 794 static void
 795 predraw_set_foreground (GdkGCWin32Data          *data,
 796                         GdkColormapPrivateWin32 *colormap_private)
 797 {
 798   COLORREF fg;
 799   LOGBRUSH logbrush;
 800   HPEN hpen;
 801   HBRUSH hbr;
 802
 803   if (colormap_private == NULL)
 804     {
 805       /* A 1 bit deep bitmap */
 806       struct
 807       {
 808         WORD palVersion;
 809         WORD palNumEntries;
 810         PALETTEENTRY palPalEntry[2];
 811       } logpal;
 812       static HPALETTE hpal = NULL;
 813
 814       if (hpal == NULL)
 815         {
 816           /* Create a b&w palette */
 817           logpal.palVersion = 0x300;
 818           logpal.palNumEntries = 2;
 819           logpal.palPalEntry[0].peRed =
 820             logpal.palPalEntry[0].peGreen =
 821             logpal.palPalEntry[0].peBlue = 0x00;
 822           logpal.palPalEntry[0].peFlags = 0x00;
 823           logpal.palPalEntry[1].peRed =
 824             logpal.palPalEntry[1].peGreen =
 825             logpal.palPalEntry[1].peBlue = 0xFF;
 826           logpal.palPalEntry[1].peFlags = 0x00;
 827           if ((hpal = CreatePalette ((LOGPALETTE *) &logpal)) == NULL)
 828             WIN32_GDI_FAILED ("CreatePalette");
 829         }
 830       SelectPalette (data->xgc, hpal, FALSE);
 831       RealizePalette (data->xgc);
 832       fg = PALETTEINDEX (data->foreground);
 833     }
 834   else if (colormap_private->xcolormap->rc_palette)
 835     {
 836       int k;
 837       if (SelectPalette (data->xgc, colormap_private->xcolormap->palette,
 838                          FALSE) == NULL)
 839         WIN32_GDI_FAILED ("SelectPalette");
 840       if (TRUE || colormap_private->xcolormap->stale)
 841         {
 842           if ((k = RealizePalette (data->xgc)) == GDI_ERROR)
 843             WIN32_GDI_FAILED ("RealizePalette");
 844           colormap_private->xcolormap->stale = FALSE;
 845         }
 846 #if 0
 847       g_print ("Selected palette %#x for gc %#x, realized %d colors\n",
 848                colormap_private->xcolormap->palette, data->xgc, k);
 849 #endif
 850     }
 851
 852   fg = gdk_colormap_color (colormap_private, data->foreground);
 853
 854   if (SetTextColor (data->xgc, fg) == CLR_INVALID)
 855     WIN32_GDI_FAILED ("SetTextColor");
 856
 857   /* Create and select pen and brush. */
 858
 859   logbrush.lbStyle = BS_SOLID;
 860   logbrush.lbColor = fg;
 861
 862   if ((hpen = ExtCreatePen (data->pen_style, data->pen_width,
 863                             &logbrush, 0, NULL)) == NULL)
 864     WIN32_GDI_FAILED ("ExtCreatePen");
 865
 866   if (SelectObject (data->xgc, hpen) == NULL)
 867     WIN32_GDI_FAILED ("SelectObject");
 868
 869   switch (data->fill_style)
 870     {
 871     case GDK_OPAQUE_STIPPLED:
 872       if ((hbr = CreatePatternBrush (GDK_DRAWABLE_XID (data->stipple))) == NULL)
 873         WIN32_GDI_FAILED ("CreatePatternBrush");
 874
 875       SetBrushOrgEx(data->xgc, data->ts_x_origin,
 876                     data->ts_y_origin, NULL);
 877
 878       break;
 879
 880     case GDK_SOLID:
 881     default:
 882       if ((hbr = CreateSolidBrush (fg)) == NULL)
 883         WIN32_GDI_FAILED ("CreateSolidBrush");
 884       break;
 885   }
 886   if (SelectObject (data->xgc, hbr) == NULL)
 887     WIN32_GDI_FAILED ("SelectObject");
 888 }
 889
 890 void
 891 predraw_set_background (GdkGCWin32Data          *data,
 892                         GdkColormapPrivateWin32 *colormap_private)
 893 {
 894   COLORREF bg = gdk_colormap_color (colormap_private, data->background);
 895
 896   if (SetBkColor (data->xgc, bg) == CLR_INVALID)
 897     WIN32_GDI_FAILED ("SetBkColor");
 898 }
 899
 900 HDC
 901 gdk_gc_predraw (GdkDrawable    *drawable,
 902                 GdkGCPrivate   *gc_private,
 903                 GdkGCValuesMask usage)
 904 {
 905   GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
 906   GdkColormapPrivateWin32 *colormap_private =
 907     (GdkColormapPrivateWin32 *) drawable_private->colormap;
 908   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
 909
 910   g_assert (data->xgc == NULL);
 911
 912   data->hwnd = GDK_DRAWABLE_XID (drawable);
 913
 914   if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
 915     {
 916       if ((data->xgc = CreateCompatibleDC (NULL)) == NULL)
 917         WIN32_GDI_FAILED ("CreateCompatibleDC");
 918
 919       if ((data->saved_dc = SaveDC (data->xgc)) == 0)
 920         WIN32_GDI_FAILED ("SaveDC");
 921
 922       if (SelectObject (data->xgc, data->hwnd) == NULL)
 923         WIN32_GDI_FAILED ("SelectObject");
 924     }
 925   else
 926     {
 927       if ((data->xgc = GetDC (data->hwnd)) == NULL)
 928         WIN32_GDI_FAILED ("GetDC");
 929
 930       if ((data->saved_dc = SaveDC (data->xgc)) == 0)
 931         WIN32_GDI_FAILED ("SaveDC");
 932     }
 933
 934   if (usage & GDK_GC_FOREGROUND)
 935     predraw_set_foreground (data, colormap_private);
 936
 937   if ((usage & GDK_GC_BACKGROUND) && (data->values_mask & GDK_GC_BACKGROUND))
 938     predraw_set_background (data, colormap_private);
 939
 940   if (usage & GDK_GC_FONT)
 941     {
 942       if (SetBkMode (data->xgc, TRANSPARENT) == 0)
 943         WIN32_GDI_FAILED ("SetBkMode");
 944
 945       if (SetTextAlign (data->xgc, TA_BASELINE) == GDI_ERROR)
 946         WIN32_GDI_FAILED ("SetTextAlign");
 947     }
 948
 949   if (data->values_mask & GDK_GC_FUNCTION)
 950     if (SetROP2 (data->xgc, data->rop2) == 0)
 951       WIN32_GDI_FAILED ("SetROP2");
 952
 953   if ((data->values_mask & GDK_GC_CLIP_MASK)
 954       && data->clip_region != NULL)
 955     {
 956       if (data->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
 957         OffsetRgn (data->clip_region,
 958                    data->clip_x_origin, data->clip_y_origin);
 959       SelectClipRgn (data->xgc, data->clip_region);
 960     }
 961
 962   return data->xgc;
 963 }
 964
 965 void
 966 gdk_gc_postdraw (GdkDrawable    *drawable,
 967                  GdkGCPrivate   *gc_private,
 968                  GdkGCValuesMask usage)
 969 {
 970   GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
 971   GdkColormapPrivateWin32 *colormap_private =
 972     (GdkColormapPrivateWin32 *) drawable_private->colormap;
 973   GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
 974   HGDIOBJ hpen = NULL;
 975   HGDIOBJ hbr = NULL;
 976
 977   if (usage & GDK_GC_FOREGROUND)
 978     {
 979       if ((hpen = GetCurrentObject (data->xgc, OBJ_PEN)) == NULL)
 980         WIN32_GDI_FAILED ("GetCurrentObject");
 981
 982       if ((hbr = GetCurrentObject (data->xgc, OBJ_BRUSH)) == NULL)
 983         WIN32_GDI_FAILED ("GetCurrentObject");
 984     }
 985
 986   if (!RestoreDC (data->xgc, data->saved_dc))
 987     WIN32_GDI_FAILED ("RestoreDC");
 988 #if 0
 989   if (colormap_private != NULL
 990       && colormap_private->xcolormap->rc_palette
 991       && colormap_private->xcolormap->stale)
 992     {
 993       SelectPalette (data->xgc, GetStockObject (DEFAULT_PALETTE), FALSE);
 994       if (!UnrealizeObject (colormap_private->xcolormap->palette))
 995         WIN32_GDI_FAILED ("UnrealizeObject");
 996     }
 997 #endif
 998   if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
 999     {
1000       if (!DeleteDC (data->xgc))
1001         WIN32_GDI_FAILED ("DeleteDC");
1002     }
1003   else
1004     {
1005       ReleaseDC (data->hwnd, data->xgc);
1006     }
1007
1008   if (hpen != NULL)
1009     if (!DeleteObject (hpen))
1010       WIN32_GDI_FAILED ("DeleteObject");
1011
1012   if (hbr != NULL)
1013     if (!DeleteObject (hbr))
1014       WIN32_GDI_FAILED ("DeleteObject");
1015
1016   if ((data->values_mask & GDK_GC_CLIP_MASK)
1017       && data->clip_region != NULL
1018       && (data->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN)))
1019     OffsetRgn (data->clip_region,
1020                -data->clip_x_origin, -data->clip_y_origin);
1021   data->xgc = NULL;
1022 }
1023
1024 /* This function originally from Jean-Edouard Lachand-Robert, and
1025  * available at www.codeguru.com. Simplified for our needs, now
1026  * handles just one-bit deep bitmaps (in Window parlance, ie those
1027  * that GDK calls bitmaps (and not pixmaps), with zero pixels being
1028  * transparent.
1029  */
1030
1031 /*
1032  *  BitmapToRegion :  Create a region from the "non-transparent" pixels of
1033  *  a bitmap
1034  *  Author :      Jean-Edouard Lachand-Robert
1035  *  (http://www.geocities.com/Paris/LeftBank/1160/resume.htm), June 1998.
1036  */
1037
1038 HRGN
1039 BitmapToRegion (HBITMAP hBmp)
1040 {
1041   HRGN hRgn = NULL;
1042   HDC hMemDC;
1043   BITMAP bm;
1044
1045   struct
1046   {
1047     BITMAPINFOHEADER bmiHeader;
1048 #if 1
1049     WORD bmiColors[2];
1050 #else
1051     RGBQUAD bmiColors[2];
1052 #endif
1053   } bmi;
1054   VOID *pbits8;
1055   HBITMAP hbm8;
1056   struct
1057   {
1058     WORD palVersion;
1059     WORD palNumEntries;
1060     PALETTEENTRY palPalEntry[2];
1061   } logpal;
1062   static HPALETTE bwPalette = NULL;
1063
1064   HBITMAP holdBmp;
1065   HDC hDC;
1066
1067   BITMAP bm8;
1068   HBITMAP holdBmp2;
1069   DWORD maxRects;
1070   RGNDATA *pData;
1071   BYTE *p8;
1072   int x, y;
1073   HRGN h;
1074
1075   /* Create a B&W palette */
1076   if (bwPalette == NULL)
1077     {
1078       /* Create a b&w palette */
1079       logpal.palVersion = 0x300;
1080       logpal.palNumEntries = 2;
1081       logpal.palPalEntry[0].peRed =
1082         logpal.palPalEntry[0].peGreen =
1083         logpal.palPalEntry[0].peBlue = 0;
1084       logpal.palPalEntry[0].peFlags = 0;
1085       logpal.palPalEntry[1].peRed =
1086         logpal.palPalEntry[1].peGreen =
1087         logpal.palPalEntry[1].peBlue = 0xFF;
1088       logpal.palPalEntry[1].peFlags = 0;
1089       if ((bwPalette = CreatePalette ((LOGPALETTE *) &logpal)) == NULL)
1090         WIN32_GDI_FAILED ("CreatePalette");
1091     }
1092
1093   /* Create a memory DC inside which we will scan the bitmap content */
1094   hMemDC = CreateCompatibleDC (NULL);
1095   if (!hMemDC)
1096     {
1097       WIN32_GDI_FAILED ("CreateCompatibleDC");
1098       return NULL;
1099     }
1100
1101   SelectPalette (hMemDC, bwPalette, FALSE);
1102   RealizePalette (hMemDC);
1103
1104   /* Get bitmap size */
1105   GetObject(hBmp, sizeof(bm), &bm);
1106
1107   /* Create a 8 bits depth bitmap and select it into the memory DC */
1108   bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
1109   bmi.bmiHeader.biWidth = bm.bmWidth;
1110   bmi.bmiHeader.biHeight = bm.bmHeight;
1111   bmi.bmiHeader.biPlanes = 1;
1112   bmi.bmiHeader.biBitCount = 8;
1113   bmi.bmiHeader.biCompression = BI_RGB;
1114   bmi.bmiHeader.biSizeImage = 0;
1115   bmi.bmiHeader.biXPelsPerMeter = 0;
1116   bmi.bmiHeader.biYPelsPerMeter = 0;
1117   bmi.bmiHeader.biClrUsed = 2;
1118   bmi.bmiHeader.biClrImportant = 2;
1119 #if 1
1120   bmi.bmiColors[0] = 0;
1121   bmi.bmiColors[1] = 1;
1122   hbm8 = CreateDIBSection (hMemDC, (BITMAPINFO *)&bmi,
1123                             DIB_PAL_COLORS, &pbits8, NULL, 0);
1124 #else
1125   bmi.bmiColors[0].rgbBlue =
1126     bmi.bmiColors[0].rgbGreen =
1127     bmi.bmiColors[0].rgbRed = 0x00;
1128   bmi.bmiColors[0].rgbReserved = 0x00;
1129
1130   bmi.bmiColors[1].rgbBlue =
1131     bmi.bmiColors[1].rgbGreen =
1132     bmi.bmiColors[1].rgbRed = 0xFF;
1133   bmi.bmiColors[0].rgbReserved = 0x00;
1134
1135   hbm8 = CreateDIBSection (hMemDC, (BITMAPINFO *)&bmi,
1136                             DIB_RGB_COLORS, &pbits8, NULL, 0);
1137 #endif
1138   if (!hbm8)
1139     {
1140       WIN32_GDI_FAILED ("CreateDIBSection");
1141       DeleteDC (hMemDC);
1142       return NULL;
1143     }
1144
1145   holdBmp = (HBITMAP) SelectObject (hMemDC, hbm8);
1146
1147   /* Create a DC just to copy the bitmap into the memory DC*/
1148   hDC = CreateCompatibleDC (hMemDC);
1149   if (!hDC)
1150     {
1151       WIN32_GDI_FAILED ("CreateCompatibleDC #2");
1152       SelectObject (hMemDC, holdBmp);
1153       DeleteObject (hbm8);
1154       DeleteDC (hMemDC);
1155       return NULL;
1156     }
1157
1158   /* Get how many bytes per row we have for the bitmap bits */
1159   GetObject (hbm8, sizeof (bm8), &bm8);
1160
1161   /* Hans Breuer found a fix to the long-standing erroneous behaviour
1162    * on NT 4.0: There seems to be a bug in Win NT 4.0 GDI: scanlines
1163    * in bitmaps are dword aligned on both Win95 and NT. In the case of
1164    * a bitmap with 22 bytes worth of width, GetObject above returns
1165    * with bmWidth == 22. On Win95 bmWidthBytes == 24, as it should be,
1166    * but on NT is it 22. We need to correct this here.
1167    */
1168   bm8.bmWidthBytes = (((bm8.bmWidthBytes-1)/4)+1)*4; /* dword aligned!! */
1169
1170   /* Copy the bitmap into the memory DC*/
1171   holdBmp2 = (HBITMAP) SelectObject (hDC, hBmp);
1172
1173   if (!BitBlt (hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY))
1174     {
1175       WIN32_GDI_FAILED ("BitBlt");
1176       SelectObject (hDC, holdBmp2);
1177       SelectObject (hMemDC, holdBmp);
1178       DeleteObject (hbm8);
1179       DeleteDC (hMemDC);
1180       return NULL;
1181     }
1182   SelectObject (hDC, holdBmp2);
1183   DeleteDC (hDC);
1184
1185   /* For better performances, we will use the ExtCreateRegion()
1186    * function to create the region. This function take a RGNDATA
1187    * structure on entry. We will add rectangles by amount of
1188    * ALLOC_UNIT number in this structure.
1189    */
1190   #define ALLOC_UNIT  100
1191   maxRects = ALLOC_UNIT;
1192
1193   pData = g_malloc (sizeof (RGNDATAHEADER) + (sizeof (RECT) * maxRects));
1194   pData->rdh.dwSize = sizeof (RGNDATAHEADER);
1195   pData->rdh.iType = RDH_RECTANGLES;
1196   pData->rdh.nCount = pData->rdh.nRgnSize = 0;
1197   SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1198
1199   /* Scan each bitmap from bottom to top (the bitmap is inverted vertically)*/
1200   p8 = (BYTE *) pbits8 + (bm8.bmHeight - 1) * bm8.bmWidthBytes;
1201   for (y = 0; y < bm.bmHeight; y++)
1202     {
1203       /* Scan each bitmap row from left to right*/
1204       for (x = 0; x < bm.bmWidth; x++)
1205         {
1206           /* Search for a continuous range of "non transparent pixels"*/
1207           int x0 = x;
1208           BYTE *p = p8 + x;
1209           while (x < bm.bmWidth)
1210             {
1211               if (*p == 0)
1212                 /* This pixel is "transparent"*/
1213                 break;
1214               p++;
1215               x++;
1216             }
1217
1218           if (x > x0)
1219             {
1220               RECT *pr;
1221               /* Add the pixels (x0, y) to (x, y+1) as a new rectangle
1222                * in the region
1223                */
1224               if (pData->rdh.nCount >= maxRects)
1225                 {
1226                   maxRects += ALLOC_UNIT;
1227                   pData = g_realloc (pData, sizeof(RGNDATAHEADER)
1228                                      + (sizeof(RECT) * maxRects));
1229                 }
1230               pr = (RECT *) &pData->Buffer;
1231               SetRect (&pr[pData->rdh.nCount], x0, y, x, y+1);
1232               if (x0 < pData->rdh.rcBound.left)
1233                 pData->rdh.rcBound.left = x0;
1234               if (y < pData->rdh.rcBound.top)
1235                 pData->rdh.rcBound.top = y;
1236               if (x > pData->rdh.rcBound.right)
1237                 pData->rdh.rcBound.right = x;
1238               if (y+1 > pData->rdh.rcBound.bottom)
1239                 pData->rdh.rcBound.bottom = y+1;
1240               pData->rdh.nCount++;
1241
1242               /* On Windows98, ExtCreateRegion() may fail if the
1243                * number of rectangles is too large (ie: >
1244                * 4000). Therefore, we have to create the region by
1245                * multiple steps.
1246                */
1247               if (pData->rdh.nCount == 2000)
1248                 {
1249                   HRGN h = ExtCreateRegion (NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
1250                   if (hRgn)
1251                     {
1252                       CombineRgn(hRgn, hRgn, h, RGN_OR);
1253                       DeleteObject(h);
1254                     }
1255                   else
1256                     hRgn = h;
1257                   pData->rdh.nCount = 0;
1258                   SetRect (&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
1259                 }
1260             }
1261         }
1262
1263       /* Go to next row (remember, the bitmap is inverted vertically)*/
1264       p8 -= bm8.bmWidthBytes;
1265     }
1266
1267   /* Create or extend the region with the remaining rectangles*/
1268   h = ExtCreateRegion (NULL, sizeof (RGNDATAHEADER)
1269                        + (sizeof (RECT) * maxRects), pData);
1270   if (hRgn)
1271     {
1272       CombineRgn (hRgn, hRgn, h, RGN_OR);
1273       DeleteObject (h);
1274     }
1275   else
1276     hRgn = h;
1277
1278   /* Clean up*/
1279   SelectObject(hMemDC, holdBmp);
1280   DeleteObject (hbm8);
1281   DeleteDC (hMemDC);
1282
1283   return hRgn;
1284 }