Pileus Git - ~andy/gtk/blob - gdk/win32/gdkdrawable-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 Lesser 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser 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-2000.  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 <math.h>
  28 #include <glib.h>
  29
  30 #include <pango/pangowin32.h>
  31
  32 #include "gdkinternals.h"
  33 #include "gdkprivate-win32.h"
  34
  35 static void gdk_win32_draw_rectangle (GdkDrawable    *drawable,
  36                                       GdkGC          *gc,
  37                                       gint            filled,
  38                                       gint            x,
  39                                       gint            y,
  40                                       gint            width,
  41                                       gint            height);
  42 static void gdk_win32_draw_arc       (GdkDrawable    *drawable,
  43                                       GdkGC          *gc,
  44                                       gint            filled,
  45                                       gint            x,
  46                                       gint            y,
  47                                       gint            width,
  48                                       gint            height,
  49                                       gint            angle1,
  50                                       gint            angle2);
  51 static void gdk_win32_draw_polygon   (GdkDrawable    *drawable,
  52                                       GdkGC          *gc,
  53                                       gint            filled,
  54                                       GdkPoint       *points,
  55                                       gint            npoints);
  56 static void gdk_win32_draw_text      (GdkDrawable    *drawable,
  57                                       GdkFont        *font,
  58                                       GdkGC          *gc,
  59                                       gint            x,
  60                                       gint            y,
  61                                       const gchar    *text,
  62                                       gint            text_length);
  63 static void gdk_win32_draw_text_wc   (GdkDrawable    *drawable,
  64                                       GdkFont        *font,
  65                                       GdkGC          *gc,
  66                                       gint            x,
  67                                       gint            y,
  68                                       const GdkWChar *text,
  69                                       gint            text_length);
  70 static void gdk_win32_draw_drawable  (GdkDrawable    *drawable,
  71                                       GdkGC          *gc,
  72                                       GdkPixmap      *src,
  73                                       gint            xsrc,
  74                                       gint            ysrc,
  75                                       gint            xdest,
  76                                       gint            ydest,
  77                                       gint            width,
  78                                       gint            height);
  79 static void gdk_win32_draw_points    (GdkDrawable    *drawable,
  80                                       GdkGC          *gc,
  81                                       GdkPoint       *points,
  82                                       gint            npoints);
  83 static void gdk_win32_draw_segments  (GdkDrawable    *drawable,
  84                                       GdkGC          *gc,
  85                                       GdkSegment     *segs,
  86                                       gint            nsegs);
  87 static void gdk_win32_draw_lines     (GdkDrawable    *drawable,
  88                                       GdkGC          *gc,
  89                                       GdkPoint       *points,
  90                                       gint            npoints);
  91 static void gdk_win32_draw_glyphs    (GdkDrawable      *drawable,
  92                                       GdkGC            *gc,
  93                                       PangoFont        *font,
  94                                       gint              x,
  95                                       gint              y,
  96                                       PangoGlyphString *glyphs);
  97 static void gdk_win32_draw_image     (GdkDrawable     *drawable,
  98                                       GdkGC           *gc,
  99                                       GdkImage        *image,
 100                                       gint             xsrc,
 101                                       gint             ysrc,
 102                                       gint             xdest,
 103                                       gint             ydest,
 104                                       gint             width,
 105                                       gint             height);
 106
 107 static void gdk_win32_set_colormap   (GdkDrawable    *drawable,
 108                                       GdkColormap    *colormap);
 109
 110 static GdkColormap* gdk_win32_get_colormap   (GdkDrawable    *drawable);
 111
 112 static gint         gdk_win32_get_depth      (GdkDrawable    *drawable);
 113
 114 static GdkVisual*   gdk_win32_get_visual     (GdkDrawable    *drawable);
 115
 116 static void gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass);
 117
 118 static gpointer parent_class = NULL;
 119
 120 GType
 121 gdk_drawable_impl_win32_get_type (void)
 122 {
 123   static GType object_type = 0;
 124
 125   if (!object_type)
 126     {
 127       static const GTypeInfo object_info =
 128       {
 129         sizeof (GdkDrawableImplWin32Class),
 130         (GBaseInitFunc) NULL,
 131         (GBaseFinalizeFunc) NULL,
 132         (GClassInitFunc) gdk_drawable_impl_win32_class_init,
 133         NULL,           /* class_finalize */
 134         NULL,           /* class_data */
 135         sizeof (GdkDrawableImplWin32),
 136         0,              /* n_preallocs */
 137         (GInstanceInitFunc) NULL,
 138       };
 139
 140       object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
 141                                             "GdkDrawableImplWin32",
 142                                             &object_info, 0);
 143     }
 144
 145   return object_type;
 146 }
 147
 148 static void
 149 gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass)
 150 {
 151   GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
 152
 153   parent_class = g_type_class_peek_parent (klass);
 154
 155   drawable_class->create_gc = _gdk_win32_gc_new;
 156   drawable_class->draw_rectangle = gdk_win32_draw_rectangle;
 157   drawable_class->draw_arc = gdk_win32_draw_arc;
 158   drawable_class->draw_polygon = gdk_win32_draw_polygon;
 159   drawable_class->draw_text = gdk_win32_draw_text;
 160   drawable_class->draw_text_wc = gdk_win32_draw_text_wc;
 161   drawable_class->draw_drawable = gdk_win32_draw_drawable;
 162   drawable_class->draw_points = gdk_win32_draw_points;
 163   drawable_class->draw_segments = gdk_win32_draw_segments;
 164   drawable_class->draw_lines = gdk_win32_draw_lines;
 165   drawable_class->draw_glyphs = gdk_win32_draw_glyphs;
 166   drawable_class->draw_image = gdk_win32_draw_image;
 167
 168   drawable_class->set_colormap = gdk_win32_set_colormap;
 169   drawable_class->get_colormap = gdk_win32_get_colormap;
 170
 171   drawable_class->get_depth = gdk_win32_get_depth;
 172   drawable_class->get_visual = gdk_win32_get_visual;
 173
 174   drawable_class->get_image = _gdk_win32_get_image;
 175 }
 176
 177 /*****************************************************
 178  * Win32 specific implementations of generic functions *
 179  *****************************************************/
 180
 181 static GdkColormap*
 182 gdk_win32_get_colormap (GdkDrawable *drawable)
 183 {
 184   GdkDrawableImplWin32 *impl;
 185
 186   impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
 187
 188   return impl->colormap;
 189 }
 190
 191 static void
 192 gdk_win32_set_colormap (GdkDrawable *drawable,
 193                         GdkColormap *colormap)
 194 {
 195   GdkDrawableImplWin32 *impl;
 196
 197   g_return_if_fail (colormap != NULL);
 198
 199   impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
 200
 201   if (impl->colormap == colormap)
 202     return;
 203
 204   if (impl->colormap)
 205     gdk_colormap_unref (impl->colormap);
 206   impl->colormap = colormap;
 207   if (impl->colormap)
 208     gdk_colormap_ref (impl->colormap);
 209 }
 210
 211 /* Drawing
 212  */
 213
 214 static void
 215 gdk_win32_draw_rectangle (GdkDrawable *drawable,
 216                           GdkGC       *gc,
 217                           gint         filled,
 218                           gint         x,
 219                           gint         y,
 220                           gint         width,
 221                           gint         height)
 222 {
 223   GdkGCWin32 *gc_private = GDK_GC_WIN32 (gc);
 224   const GdkGCValuesMask mask = GDK_GC_FOREGROUND|GDK_GC_BACKGROUND;
 225   HDC hdc;
 226   HGDIOBJ old_pen_or_brush;
 227   POINT pts[4];
 228   gboolean ok = TRUE;
 229
 230   GDK_NOTE (MISC, g_print ("gdk_win32_draw_rectangle: %#x (%p) %s%dx%d@+%d+%d\n",
 231                            (guint) GDK_DRAWABLE_HANDLE (drawable),
 232                            gc_private,
 233                            (filled ? "fill " : ""),
 234                            width, height, x, y));
 235
 236   hdc = gdk_win32_hdc_get (drawable, gc, mask);
 237
 238 #if 0
 239   {
 240     HBRUSH hbr = GetCurrentObject (hdc, OBJ_BRUSH);
 241     HPEN hpen = GetCurrentObject (hdc, OBJ_PEN);
 242     LOGBRUSH lbr;
 243     LOGPEN lpen;
 244     GetObject (hbr, sizeof (lbr), &lbr);
 245     GetObject (hpen, sizeof (lpen), &lpen);
 246
 247     g_print ("current brush: style = %s, color = 0x%.08x\n",
 248              (lbr.lbStyle == BS_SOLID ? "SOLID" : "???"),
 249              lbr.lbColor);
 250     g_print ("current pen: style = %s, width = %d, color = 0x%.08x\n",
 251              (lpen.lopnStyle == PS_SOLID ? "SOLID" : "???"),
 252              lpen.lopnWidth,
 253              lpen.lopnColor);
 254   }
 255 #endif
 256
 257   if (gc_private->fill_style == GDK_OPAQUE_STIPPLED)
 258     {
 259       if (!BeginPath (hdc))
 260         WIN32_GDI_FAILED ("BeginPath"), ok = FALSE;
 261
 262       /* Win9x doesn't support Rectangle calls in a path,
 263        * thus use Polyline.
 264        */
 265
 266       pts[0].x = x;
 267       pts[0].y = y;
 268       pts[1].x = x + width + 1;
 269       pts[1].y = y;
 270       pts[2].x = x + width + 1;
 271       pts[2].y = y + height + 1;
 272       pts[3].x = x;
 273       pts[3].y = y + height + 1;
 274
 275       if (ok)
 276         MoveToEx (hdc, x, y, NULL);
 277
 278       if (ok && !Polyline (hdc, pts, 4))
 279         WIN32_GDI_FAILED ("Polyline"), ok = FALSE;
 280
 281       if (ok && !CloseFigure (hdc))
 282         WIN32_GDI_FAILED ("CloseFigure"), ok = FALSE;
 283
 284       if (ok && !EndPath (hdc))
 285         WIN32_GDI_FAILED ("EndPath"), ok = FALSE;
 286
 287       if (ok && !filled)
 288         if (!WidenPath (hdc))
 289           WIN32_GDI_FAILED ("WidenPath"), ok = FALSE;
 290
 291       if (ok && !FillPath (hdc))
 292         WIN32_GDI_FAILED ("FillPath"), ok = FALSE;
 293     }
 294   else
 295     {
 296       if (filled)
 297         old_pen_or_brush = SelectObject (hdc, GetStockObject (NULL_PEN));
 298       else
 299         old_pen_or_brush = SelectObject (hdc, GetStockObject (HOLLOW_BRUSH));
 300
 301       if (!Rectangle (hdc, x, y, x+width+1, y+height+1))
 302         WIN32_GDI_FAILED ("Rectangle");
 303
 304       SelectObject (hdc, old_pen_or_brush);
 305     }
 306
 307   gdk_win32_hdc_release (drawable, gc, mask);
 308 }
 309
 310 static void
 311 gdk_win32_draw_arc (GdkDrawable *drawable,
 312                     GdkGC       *gc,
 313                     gint         filled,
 314                     gint         x,
 315                     gint         y,
 316                     gint         width,
 317                     gint         height,
 318                     gint         angle1,
 319                     gint         angle2)
 320 {
 321   const GdkGCValuesMask mask = GDK_GC_FOREGROUND|GDK_GC_BACKGROUND;
 322   HDC hdc;
 323   int nXStartArc, nYStartArc, nXEndArc, nYEndArc;
 324
 325   GDK_NOTE (MISC, g_print ("gdk_draw_arc: %#x  %d,%d,%d,%d  %d %d\n",
 326                            (guint) GDK_DRAWABLE_HANDLE (drawable),
 327                            x, y, width, height, angle1, angle2));
 328
 329   /* Seems that drawing arcs with width or height <= 2 fails, at least
 330    * with my TNT card.
 331    */
 332   if (width <= 2 || height <= 2 || angle2 == 0)
 333     return;
 334
 335   hdc = gdk_win32_hdc_get (drawable, gc, mask);
 336
 337   if (angle2 >= 360*64)
 338     {
 339       nXStartArc = nYStartArc = nXEndArc = nYEndArc = 0;
 340     }
 341   else if (angle2 > 0)
 342     {
 343       /* The 100. is just an arbitrary value */
 344       nXStartArc = x + width/2 + 100. * cos(angle1/64.*2.*G_PI/360.);
 345       nYStartArc = y + height/2 + -100. * sin(angle1/64.*2.*G_PI/360.);
 346       nXEndArc = x + width/2 + 100. * cos((angle1+angle2)/64.*2.*G_PI/360.);
 347       nYEndArc = y + height/2 + -100. * sin((angle1+angle2)/64.*2.*G_PI/360.);
 348     }
 349   else
 350     {
 351       nXEndArc = x + width/2 + 100. * cos(angle1/64.*2.*G_PI/360.);
 352       nYEndArc = y + height/2 + -100. * sin(angle1/64.*2.*G_PI/360.);
 353       nXStartArc = x + width/2 + 100. * cos((angle1+angle2)/64.*2.*G_PI/360.);
 354       nYStartArc = y + height/2 + -100. * sin((angle1+angle2)/64.*2.*G_PI/360.);
 355     }
 356
 357   /* GDK_OPAQUE_STIPPLED arcs not implemented. */
 358
 359   if (filled)
 360     {
 361       GDK_NOTE (MISC, g_print ("...Pie(hdc,%d,%d,%d,%d,%d,%d,%d,%d)\n",
 362                                x, y, x+width, y+height,
 363                                nXStartArc, nYStartArc,
 364                                nXEndArc, nYEndArc));
 365       if (!Pie (hdc, x, y, x+width, y+height,
 366                 nXStartArc, nYStartArc, nXEndArc, nYEndArc))
 367         WIN32_GDI_FAILED ("Pie");
 368     }
 369   else
 370     {
 371       GDK_NOTE (MISC, g_print ("...Arc(hdc,%d,%d,%d,%d,%d,%d,%d,%d)\n",
 372                                x, y, x+width, y+height,
 373                                nXStartArc, nYStartArc,
 374                                nXEndArc, nYEndArc));
 375       if (!Arc (hdc, x, y, x+width, y+height,
 376                 nXStartArc, nYStartArc, nXEndArc, nYEndArc))
 377         WIN32_GDI_FAILED ("Arc");
 378     }
 379   gdk_win32_hdc_release (drawable, gc, mask);
 380 }
 381
 382 static void
 383 gdk_win32_draw_polygon (GdkDrawable *drawable,
 384                         GdkGC       *gc,
 385                         gint         filled,
 386                         GdkPoint    *points,
 387                         gint         npoints)
 388 {
 389   GdkGCWin32 *gc_private = GDK_GC_WIN32 (gc);
 390   const GdkGCValuesMask mask = GDK_GC_FOREGROUND|GDK_GC_BACKGROUND;
 391   HDC hdc;
 392   POINT *pts;
 393   gboolean ok = TRUE;
 394   int i;
 395
 396   GDK_NOTE (MISC, g_print ("gdk_win32_draw_polygon: %#x (%p) %d\n",
 397                            (guint) GDK_DRAWABLE_HANDLE (drawable),
 398                            gc_private,
 399                            npoints));
 400
 401   if (npoints < 2)
 402     return;
 403
 404   hdc = gdk_win32_hdc_get (drawable, gc, mask);
 405   pts = g_new (POINT, npoints+1);
 406
 407   for (i = 0; i < npoints; i++)
 408     {
 409       pts[i].x = points[i].x;
 410       pts[i].y = points[i].y;
 411     }
 412
 413   if (gc_private->fill_style == GDK_OPAQUE_STIPPLED)
 414     {
 415       if (!BeginPath (hdc))
 416         WIN32_GDI_FAILED ("BeginPath"), ok = FALSE;
 417
 418       if (ok)
 419         MoveToEx (hdc, points[0].x, points[0].y, NULL);
 420
 421       if (pts[0].x == pts[npoints-1].x && pts[0].y == pts[npoints-1].y)
 422         npoints--;
 423
 424       if (ok && !Polyline (hdc, pts, 4))
 425         WIN32_GDI_FAILED ("Polyline"), ok = FALSE;
 426
 427       if (ok && !CloseFigure (hdc))
 428         WIN32_GDI_FAILED ("CloseFigure"), ok = FALSE;
 429
 430       if (ok && !EndPath (hdc))
 431         WIN32_GDI_FAILED ("EndPath"), ok = FALSE;
 432
 433       if (ok && !filled)
 434         if (!WidenPath (hdc))
 435           WIN32_GDI_FAILED ("WidenPath"), ok = FALSE;
 436
 437       if (ok && !FillPath (hdc))
 438         WIN32_GDI_FAILED ("FillPath"), ok = FALSE;
 439     }
 440   else
 441     {
 442       if (points[0].x != points[npoints-1].x
 443           || points[0].y != points[npoints-1].y)
 444         {
 445           pts[npoints].x = points[0].x;
 446           pts[npoints].y = points[0].y;
 447           npoints++;
 448         }
 449
 450       if (filled)
 451         {
 452           if (!Polygon (hdc, pts, npoints))
 453             WIN32_GDI_FAILED ("Polygon");
 454         }
 455       else
 456         {
 457           if (!Polyline (hdc, pts, npoints))
 458             WIN32_GDI_FAILED ("Polyline");
 459         }
 460     }
 461   g_free (pts);
 462   gdk_win32_hdc_release (drawable, gc, mask);
 463 }
 464
 465 typedef struct
 466 {
 467   gint x, y;
 468   HDC hdc;
 469 } gdk_draw_text_arg;
 470
 471 static void
 472 gdk_draw_text_handler (GdkWin32SingleFont *singlefont,
 473                        const wchar_t      *wcstr,
 474                        int                 wclen,
 475                        void               *arg)
 476 {
 477   HGDIOBJ oldfont;
 478   SIZE size;
 479   gdk_draw_text_arg *argp = (gdk_draw_text_arg *) arg;
 480
 481   if (!singlefont)
 482     return;
 483
 484   if ((oldfont = SelectObject (argp->hdc, singlefont->hfont)) == NULL)
 485     {
 486       WIN32_GDI_FAILED ("SelectObject");
 487       return;
 488     }
 489
 490   if (!TextOutW (argp->hdc, argp->x, argp->y, wcstr, wclen))
 491     WIN32_GDI_FAILED ("TextOutW");
 492   GetTextExtentPoint32W (argp->hdc, wcstr, wclen, &size);
 493   argp->x += size.cx;
 494
 495   SelectObject (argp->hdc, oldfont);
 496 }
 497
 498 static void
 499 gdk_win32_draw_text (GdkDrawable *drawable,
 500                      GdkFont     *font,
 501                      GdkGC       *gc,
 502                      gint         x,
 503                      gint         y,
 504                      const gchar *text,
 505                      gint         text_length)
 506 {
 507   const GdkGCValuesMask mask = GDK_GC_FOREGROUND|GDK_GC_FONT;
 508   wchar_t *wcstr, wc;
 509   gint wlen;
 510   gdk_draw_text_arg arg;
 511
 512   if (text_length == 0)
 513     return;
 514
 515   g_assert (font->type == GDK_FONT_FONT || font->type == GDK_FONT_FONTSET);
 516
 517   arg.x = x;
 518   arg.y = y;
 519   arg.hdc = gdk_win32_hdc_get (drawable, gc, mask);
 520
 521   GDK_NOTE (MISC, g_print ("gdk_draw_text: %#x (%d,%d) \"%.*s\" (len %d)\n",
 522                            (guint) GDK_DRAWABLE_HANDLE (drawable),
 523                            x, y,
 524                            (text_length > 10 ? 10 : text_length),
 525                            text, text_length));
 526
 527   if (text_length == 1)
 528     {
 529       /* For single characters, don't try to interpret as UTF-8. */
 530       wc = (guchar) text[0];
 531       gdk_wchar_text_handle (font, &wc, 1, gdk_draw_text_handler, &arg);
 532     }
 533   else
 534     {
 535       wcstr = g_new (wchar_t, text_length);
 536       if ((wlen = gdk_nmbstowchar_ts (wcstr, text, text_length, text_length)) == -1)
 537         g_warning ("gdk_win32_draw_text: gdk_nmbstowchar_ts failed");
 538       else
 539         gdk_wchar_text_handle (font, wcstr, wlen, gdk_draw_text_handler, &arg);
 540       g_free (wcstr);
 541     }
 542
 543
 544   gdk_win32_hdc_release (drawable, gc, mask);
 545 }
 546
 547 static void
 548 gdk_win32_draw_text_wc (GdkDrawable      *drawable,
 549                         GdkFont          *font,
 550                         GdkGC            *gc,
 551                         gint              x,
 552                         gint              y,
 553                         const GdkWChar *text,
 554                         gint              text_length)
 555 {
 556   const GdkGCValuesMask mask = GDK_GC_FOREGROUND|GDK_GC_FONT;
 557   gint i;
 558   wchar_t *wcstr;
 559   gdk_draw_text_arg arg;
 560
 561   if (text_length == 0)
 562     return;
 563
 564   g_assert (font->type == GDK_FONT_FONT || font->type == GDK_FONT_FONTSET);
 565
 566   arg.x = x;
 567   arg.y = y;
 568   arg.hdc = gdk_win32_hdc_get (drawable, gc, mask);
 569
 570   GDK_NOTE (MISC, g_print ("gdk_draw_text_wc: %#x (%d,%d) len: %d\n",
 571                            (guint) GDK_DRAWABLE_HANDLE (drawable),
 572                            x, y, text_length));
 573
 574   if (sizeof (wchar_t) != sizeof (GdkWChar))
 575     {
 576       wcstr = g_new (wchar_t, text_length);
 577       for (i = 0; i < text_length; i++)
 578         wcstr[i] = text[i];
 579     }
 580   else
 581     wcstr = (wchar_t *) text;
 582
 583   gdk_wchar_text_handle (font, wcstr, text_length,
 584                          gdk_draw_text_handler, &arg);
 585
 586   if (sizeof (wchar_t) != sizeof (GdkWChar))
 587     g_free (wcstr);
 588
 589   gdk_win32_hdc_release (drawable, gc, mask);
 590 }
 591
 592 static void
 593 gdk_win32_draw_drawable (GdkDrawable *drawable,
 594                          GdkGC       *gc,
 595                          GdkPixmap   *src,
 596                          gint         xsrc,
 597                          gint         ysrc,
 598                          gint         xdest,
 599                          gint         ydest,
 600                          gint         width,
 601                          gint         height)
 602 {
 603   HDC hdc;
 604   HDC srcdc;
 605   HGDIOBJ hgdiobj;
 606   HRGN src_rgn, draw_rgn, outside_rgn;
 607   RECT r;
 608   gint src_width, src_height;
 609   gboolean ok = TRUE;
 610
 611   GDK_NOTE (MISC, g_print ("gdk_draw_pixmap: dest: %#x @+%d+%d"
 612                            "src: %#x %dx%d@+%d+%d\n",
 613                            (guint) GDK_DRAWABLE_HANDLE (drawable),
 614                            xdest, ydest,
 615                            (guint) GDK_PIXMAP_HBITMAP (src),
 616                            width, height, xsrc, ysrc));
 617
 618   hdc = gdk_win32_hdc_get (drawable, gc, 0);
 619
 620   gdk_drawable_get_size (src, &src_width, &src_height);
 621   src_rgn = CreateRectRgn (0, 0, src_width + 1, src_height + 1);
 622   draw_rgn = CreateRectRgn (xsrc, ysrc, xsrc + width + 1, ysrc + height + 1);
 623
 624   if (GDK_IS_WINDOW (drawable))
 625     {
 626       /* If we are drawing on a window, calculate the region that is
 627        * outside the source pixmap, and invalidate that, causing it to
 628        * be cleared. XXX
 629        */
 630       SetRectEmpty (&r);
 631       outside_rgn = CreateRectRgnIndirect (&r);
 632       if (CombineRgn (outside_rgn, draw_rgn, src_rgn, RGN_DIFF) != NULLREGION)
 633         {
 634           OffsetRgn (outside_rgn, xdest, ydest);
 635           GDK_NOTE (MISC, (GetRgnBox (outside_rgn, &r),
 636                            g_print ("...calling InvalidateRgn, "
 637                                     "bbox: %ldx%ld@+%ld+%ld\n",
 638                                     r.right - r.left - 1, r.bottom - r.top - 1,
 639                                     r.left, r.top)));
 640           InvalidateRgn (GDK_DRAWABLE_HANDLE (drawable), outside_rgn, TRUE);
 641         }
 642       DeleteObject (outside_rgn);
 643     }
 644
 645 #if 1 /* Don't know if this is necessary  */
 646   if (CombineRgn (draw_rgn, draw_rgn, src_rgn, RGN_AND) == COMPLEXREGION)
 647     g_warning ("gdk_win32_draw_drawable: CombineRgn returned a COMPLEXREGION");
 648
 649   GetRgnBox (draw_rgn, &r);
 650   if (r.left != xsrc
 651       || r.top != ysrc
 652       || r.right != xsrc + width + 1
 653       || r.bottom != ysrc + height + 1)
 654     {
 655       xdest += r.left - xsrc;
 656       xsrc = r.left;
 657       ydest += r.top - ysrc;
 658       ysrc = r.top;
 659       width = r.right - xsrc - 1;
 660       height = r.bottom - ysrc - 1;
 661
 662       GDK_NOTE (MISC, g_print ("... restricted to src: %dx%d@+%d+%d, "
 663                                "dest: @+%d+%d\n",
 664                                width, height, xsrc, ysrc,
 665                                xdest, ydest));
 666     }
 667 #endif
 668
 669   DeleteObject (src_rgn);
 670   DeleteObject (draw_rgn);
 671
 672   /* This function is called also to bitblt from a window.
 673    */
 674   if (GDK_IS_PIXMAP (src))
 675     {
 676       if ((srcdc = CreateCompatibleDC (hdc)) == NULL)
 677         WIN32_GDI_FAILED ("CreateCompatibleDC"), ok = FALSE;
 678
 679       if (ok && (hgdiobj = SelectObject (srcdc, GDK_PIXMAP_HBITMAP (src))) == NULL)
 680         WIN32_GDI_FAILED ("SelectObject"), ok = FALSE;
 681
 682       if (ok && !BitBlt (hdc, xdest, ydest, width, height,
 683                          srcdc, xsrc, ysrc, SRCCOPY))
 684         WIN32_GDI_FAILED ("BitBlt");
 685
 686       if (ok && (SelectObject (srcdc, hgdiobj) == NULL))
 687         WIN32_GDI_FAILED ("SelectObject");
 688
 689       if (srcdc != NULL && !DeleteDC (srcdc))
 690         WIN32_GDI_FAILED ("DeleteDC");
 691     }
 692   else if (GDK_DRAWABLE_HANDLE (drawable) == GDK_DRAWABLE_HANDLE (src))
 693     {
 694       /* Blitting inside a window, use ScrollDC */
 695       RECT scrollRect, clipRect, emptyRect;
 696       HRGN updateRgn;
 697
 698       scrollRect.left = MIN (xsrc, xdest);
 699       scrollRect.top = MIN (ysrc, ydest);
 700       scrollRect.right = MAX (xsrc + width + 1, xdest + width + 1);
 701       scrollRect.bottom = MAX (ysrc + height + 1, ydest + height + 1);
 702
 703       clipRect.left = xdest;
 704       clipRect.top = ydest;
 705       clipRect.right = xdest + width + 1;
 706       clipRect.bottom = ydest + height + 1;
 707
 708       SetRectEmpty (&emptyRect);
 709       updateRgn = CreateRectRgnIndirect (&emptyRect);
 710       if (!ScrollDC (hdc, xdest - xsrc, ydest - ysrc,
 711                      &scrollRect, &clipRect,
 712                      updateRgn, NULL))
 713         WIN32_GDI_FAILED ("ScrollDC"), ok = FALSE;
 714       if (ok && !InvalidateRgn (GDK_WINDOW_HWND (drawable), updateRgn, FALSE))
 715         WIN32_GDI_FAILED ("InvalidateRgn"), ok = FALSE;
 716       if (ok && !UpdateWindow (GDK_WINDOW_HWND (drawable)))
 717         WIN32_GDI_FAILED ("UpdateWindow");
 718       DeleteObject (updateRgn);
 719     }
 720   else
 721     {
 722       if ((srcdc = GetDC (GDK_WINDOW_HWND (src))) == NULL)
 723         WIN32_GDI_FAILED ("GetDC"), ok = FALSE;
 724
 725       if (ok && !BitBlt (hdc, xdest, ydest, width, height,
 726                          srcdc, xsrc, ysrc, SRCCOPY))
 727         WIN32_GDI_FAILED ("BitBlt");
 728       ReleaseDC (GDK_WINDOW_HWND (src), srcdc);
 729     }
 730   gdk_win32_hdc_release (drawable, gc, 0);
 731 }
 732
 733 static void
 734 gdk_win32_draw_points (GdkDrawable *drawable,
 735                        GdkGC       *gc,
 736                        GdkPoint    *points,
 737                        gint         npoints)
 738 {
 739   HDC hdc;
 740   COLORREF fg;
 741   GdkGCWin32 *gc_private = GDK_GC_WIN32 (gc);
 742   GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
 743   int i;
 744
 745   hdc = gdk_win32_hdc_get (drawable, gc, 0);
 746
 747   fg = gdk_colormap_color (impl->colormap, gc_private->foreground);
 748
 749   GDK_NOTE (MISC, g_print ("gdk_draw_points: %#x %dx%.06x\n",
 750                            (guint) GDK_DRAWABLE_HANDLE (drawable),
 751                            npoints, (guint) fg));
 752
 753   for (i = 0; i < npoints; i++)
 754     SetPixel (hdc, points[i].x, points[i].y, fg);
 755
 756   gdk_win32_hdc_release (drawable, gc, 0);
 757 }
 758
 759 static void
 760 gdk_win32_draw_segments (GdkDrawable *drawable,
 761                          GdkGC       *gc,
 762                          GdkSegment  *segs,
 763                          gint         nsegs)
 764 {
 765   GdkGCWin32 *gc_private = GDK_GC_WIN32 (gc);
 766   const GdkGCValuesMask mask = GDK_GC_FOREGROUND|GDK_GC_BACKGROUND;
 767   HDC hdc;
 768   gboolean ok = TRUE;
 769   int i;
 770
 771   GDK_NOTE (MISC, g_print ("gdk_win32_draw_segments: %#x nsegs: %d\n",
 772                            (guint) GDK_DRAWABLE_HANDLE (drawable), nsegs));
 773
 774   hdc = gdk_win32_hdc_get (drawable, gc, mask);
 775
 776   if (gc_private->fill_style == GDK_OPAQUE_STIPPLED)
 777     {
 778       if (!BeginPath (hdc))
 779         WIN32_GDI_FAILED ("BeginPath"), ok = FALSE;
 780
 781       for (i = 0; ok && i < nsegs; i++)
 782         {
 783           if (ok && !MoveToEx (hdc, segs[i].x1, segs[i].y1, NULL))
 784             WIN32_GDI_FAILED ("MoveToEx"), ok = FALSE;
 785           if (ok && !LineTo (hdc, segs[i].x2, segs[i].y2))
 786             WIN32_GDI_FAILED ("LineTo"), ok = FALSE;
 787
 788           /* Draw end pixel */
 789           if (ok && gc_private->pen_width <= 1)
 790             if (!LineTo (hdc, segs[i].x2 + 1, segs[i].y2))
 791               WIN32_GDI_FAILED ("LineTo"), ok = FALSE;
 792         }
 793
 794       if (ok && !EndPath (hdc))
 795         WIN32_GDI_FAILED ("EndPath"), ok = FALSE;
 796
 797       if (ok && !WidenPath (hdc))
 798         WIN32_GDI_FAILED ("WidenPath"), ok = FALSE;
 799
 800       if (ok && !FillPath (hdc))
 801         WIN32_GDI_FAILED ("FillPath"), ok = FALSE;
 802     }
 803   else
 804     {
 805       for (i = 0; ok && i < nsegs; i++)
 806         {
 807           if (!MoveToEx (hdc, segs[i].x1, segs[i].y1, NULL))
 808             WIN32_GDI_FAILED ("MoveToEx"), ok = FALSE;
 809           if (ok && !LineTo (hdc, segs[i].x2, segs[i].y2))
 810             WIN32_GDI_FAILED ("LineTo"), ok = FALSE;
 811
 812           /* Draw end pixel */
 813           if (ok && gc_private->pen_width <= 1)
 814             if (!LineTo (hdc, segs[i].x2 + 1, segs[i].y2))
 815               WIN32_GDI_FAILED ("LineTo"), ok = FALSE;
 816         }
 817     }
 818   gdk_win32_hdc_release (drawable, gc, mask);
 819 }
 820
 821 static void
 822 gdk_win32_draw_lines (GdkDrawable *drawable,
 823                       GdkGC       *gc,
 824                       GdkPoint    *points,
 825                       gint         npoints)
 826 {
 827   GdkGCWin32 *gc_private = GDK_GC_WIN32 (gc);
 828   const GdkGCValuesMask mask = GDK_GC_FOREGROUND|GDK_GC_BACKGROUND;
 829   HDC hdc;
 830   POINT *pts;
 831   int i;
 832   gboolean ok = TRUE;
 833
 834   if (npoints < 2)
 835     return;
 836
 837   hdc = gdk_win32_hdc_get (drawable, gc, mask);
 838
 839   pts = g_new (POINT, npoints);
 840
 841   for (i = 0; i < npoints; i++)
 842     {
 843       pts[i].x = points[i].x;
 844       pts[i].y = points[i].y;
 845     }
 846
 847   if (!Polyline (hdc, pts, npoints))
 848     WIN32_GDI_FAILED ("Polyline"), ok = FALSE;
 849
 850   g_free (pts);
 851
 852   /* Draw end pixel */
 853   if (ok && gc_private->pen_width <= 1)
 854     {
 855       MoveToEx (hdc, points[npoints-1].x, points[npoints-1].y, NULL);
 856       if (!LineTo (hdc, points[npoints-1].x + 1, points[npoints-1].y))
 857         WIN32_GDI_FAILED ("LineTo");
 858     }
 859   gdk_win32_hdc_release (drawable, gc, mask);
 860 }
 861
 862 static void
 863 gdk_win32_draw_glyphs (GdkDrawable      *drawable,
 864                        GdkGC            *gc,
 865                        PangoFont        *font,
 866                        gint              x,
 867                        gint              y,
 868                        PangoGlyphString *glyphs)
 869 {
 870   const GdkGCValuesMask mask = GDK_GC_FOREGROUND;
 871   HDC hdc;
 872
 873   hdc = gdk_win32_hdc_get (drawable, gc, mask);
 874
 875   /* HB: Maybe there should be a GDK_GC_PANGO flag for hdc_get */
 876   /* default write mode is transparent (leave background) */
 877   if (SetBkMode (hdc, TRANSPARENT) == 0)
 878     WIN32_GDI_FAILED ("SetBkMode");
 879
 880   if (GDI_ERROR == SetTextAlign (hdc, TA_LEFT|TA_BOTTOM|TA_NOUPDATECP))
 881     WIN32_GDI_FAILED ("SetTextAlign");
 882
 883   pango_win32_render (hdc, font, glyphs, x, y);
 884
 885   gdk_win32_hdc_release (drawable, gc, mask);
 886 }
 887
 888 static void
 889 gdk_win32_draw_image (GdkDrawable     *drawable,
 890                       GdkGC           *gc,
 891                       GdkImage        *image,
 892                       gint             xsrc,
 893                       gint             ysrc,
 894                       gint             xdest,
 895                       gint             ydest,
 896                       gint             width,
 897                       gint             height)
 898 {
 899   GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
 900   GdkImagePrivateWin32 *image_private = (GdkImagePrivateWin32 *) image;
 901   GdkColormapPrivateWin32 *colormap_private = (GdkColormapPrivateWin32 *) impl->colormap;
 902   HDC hdc, memdc;
 903   HGDIOBJ oldbitmap;
 904   DIBSECTION ds;
 905   static struct {
 906     BITMAPINFOHEADER bmiHeader;
 907     WORD bmiIndices[256];
 908   } bmi;
 909   static gboolean bmi_inited = FALSE;
 910   gboolean ok = TRUE;
 911   int i;
 912
 913   hdc = gdk_win32_hdc_get (drawable, gc, 0);
 914
 915   if (colormap_private && colormap_private->xcolormap->rc_palette)
 916     {
 917       if (!bmi_inited)
 918         {
 919           for (i = 0; i < 256; i++)
 920             bmi.bmiIndices[i] = i;
 921           bmi_inited = TRUE;
 922         }
 923
 924       if (GetObject (image_private->hbitmap, sizeof (DIBSECTION),
 925                      &ds) != sizeof (DIBSECTION))
 926         WIN32_GDI_FAILED ("GetObject"), ok = FALSE;
 927 #if 0
 928       g_print("xdest = %d, ydest = %d, xsrc = %d, ysrc = %d, width = %d, height = %d\n",
 929               xdest, ydest, xsrc, ysrc, width, height);
 930       g_print("bmWidth = %d, bmHeight = %d, bmBitsPixel = %d, bmBits = %p\n",
 931               ds.dsBm.bmWidth, ds.dsBm.bmHeight, ds.dsBm.bmBitsPixel, ds.dsBm.bmBits);
 932       g_print("biWidth = %d, biHeight = %d, biBitCount = %d, biClrUsed = %d\n",
 933               ds.dsBmih.biWidth, ds.dsBmih.biHeight, ds.dsBmih.biBitCount, ds.dsBmih.biClrUsed);
 934 #endif
 935       bmi.bmiHeader = ds.dsBmih;
 936       /* I have spent hours on getting the parameters to
 937        * SetDIBitsToDevice right. I wonder what drugs the guys in
 938        * Redmond were on when they designed this API.
 939        */
 940       if (ok && SetDIBitsToDevice (hdc,
 941                                    xdest, ydest,
 942                                    width, height,
 943                                    xsrc, (-ds.dsBmih.biHeight)-height-ysrc,
 944                                    0, -ds.dsBmih.biHeight,
 945                                    ds.dsBm.bmBits,
 946                                    (CONST BITMAPINFO *) &bmi,
 947                                    DIB_PAL_COLORS) == 0)
 948         WIN32_GDI_FAILED ("SetDIBitsToDevice");
 949     }
 950   else
 951     {
 952
 953       if ((memdc = CreateCompatibleDC (hdc)) == NULL)
 954         WIN32_GDI_FAILED ("CreateCompatibleDC"), ok = FALSE;
 955
 956       if (ok && (oldbitmap = SelectObject (memdc, image_private->hbitmap)) == NULL)
 957         WIN32_GDI_FAILED ("SelectObject"), ok = FALSE;
 958
 959       if (ok && !BitBlt (hdc, xdest, ydest, width, height,
 960                          memdc, xsrc, ysrc, SRCCOPY))
 961         WIN32_GDI_FAILED ("BitBlt");
 962
 963       if (oldbitmap != NULL && SelectObject (memdc, oldbitmap) == NULL)
 964         WIN32_GDI_FAILED ("SelectObject");
 965
 966       if (memdc != NULL && !DeleteDC (memdc))
 967         WIN32_GDI_FAILED ("DeleteDC");
 968     }
 969   gdk_win32_hdc_release (drawable, gc, 0);
 970 }
 971
 972 static gint
 973 gdk_win32_get_depth (GdkDrawable *drawable)
 974 {
 975   /* This is a bit bogus but I'm not sure the other way is better */
 976
 977   return gdk_drawable_get_depth (GDK_DRAWABLE_IMPL_WIN32 (drawable)->wrapper);
 978 }
 979
 980 static GdkVisual*
 981 gdk_win32_get_visual (GdkDrawable *drawable)
 982 {
 983   return gdk_drawable_get_visual (GDK_DRAWABLE_IMPL_WIN32 (drawable)->wrapper);
 984 }