src/gtk1/dcclient.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dcclient.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Markus Holzem, Chris Breeze
   7 // Licence:           wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation "dcclient.h"
  12 #endif
  13
  14 #include "wx/dcclient.h"
  15 #include "wx/dcmemory.h"
  16 #include "wx/image.h"
  17 #include "wx/gtk/win_gtk.h"
  18 #include <math.h>               // for floating-point functions
  19
  20 #include "gdk/gdk.h"
  21 #include "gtk/gtk.h"
  22
  23 //-----------------------------------------------------------------------------
  24 // local data
  25 //-----------------------------------------------------------------------------
  26
  27 #include "bdiag.xbm"
  28 #include "fdiag.xbm"
  29 #include "cdiag.xbm"
  30 #include "horiz.xbm"
  31 #include "verti.xbm"
  32 #include "cross.xbm"
  33 #define  num_hatches 6
  34
  35 static GdkPixmap  *hatches[num_hatches];
  36 static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
  37
  38 //-----------------------------------------------------------------------------
  39 // constants
  40 //-----------------------------------------------------------------------------
  41
  42 #define RAD2DEG 57.2957795131
  43
  44 //-----------------------------------------------------------------------------
  45 // temporary implementation of the missing GDK function
  46 //-----------------------------------------------------------------------------
  47
  48 #include "gdk/gdkprivate.h"
  49
  50 void gdk_draw_bitmap     (GdkDrawable  *drawable,
  51                           GdkGC               *gc,
  52                           GdkDrawable  *src,
  53                           gint                xsrc,
  54                           gint                ysrc,
  55                           gint                xdest,
  56                           gint                ydest,
  57                           gint                width,
  58                           gint                height)
  59 {
  60     GdkWindowPrivate *drawable_private;
  61     GdkWindowPrivate *src_private;
  62     GdkGCPrivate *gc_private;
  63
  64     g_return_if_fail (drawable != NULL);
  65     g_return_if_fail (src != NULL);
  66     g_return_if_fail (gc != NULL);
  67
  68     drawable_private = (GdkWindowPrivate*) drawable;
  69     src_private = (GdkWindowPrivate*) src;
  70     if (drawable_private->destroyed || src_private->destroyed)
  71         return;
  72
  73     gc_private = (GdkGCPrivate*) gc;
  74
  75     if (width == -1) width = src_private->width;
  76     if (height == -1) height = src_private->height;
  77
  78     XCopyPlane( drawable_private->xdisplay,
  79                 src_private->xwindow,
  80                 drawable_private->xwindow,
  81                 gc_private->xgc,
  82                 xsrc, ysrc,
  83                 width, height,
  84                 xdest, ydest,
  85                 1 );
  86 }
  87
  88 //-----------------------------------------------------------------------------
  89 // wxWindowDC
  90 //-----------------------------------------------------------------------------
  91
  92 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
  93
  94 wxWindowDC::wxWindowDC()
  95 {
  96     m_penGC = (GdkGC *) NULL;
  97     m_brushGC = (GdkGC *) NULL;
  98     m_textGC = (GdkGC *) NULL;
  99     m_bgGC = (GdkGC *) NULL;
 100     m_cmap = (GdkColormap *) NULL;
 101     m_isMemDC = FALSE;
 102     m_owner = (wxWindow *)NULL;
 103 }
 104
 105 wxWindowDC::wxWindowDC( wxWindow *window )
 106 {
 107     m_penGC = (GdkGC *) NULL;
 108     m_brushGC = (GdkGC *) NULL;
 109     m_textGC = (GdkGC *) NULL;
 110     m_bgGC = (GdkGC *) NULL;
 111     m_cmap = (GdkColormap *) NULL;
 112     m_owner = (wxWindow *)NULL;
 113     m_isMemDC = FALSE;
 114     m_font = window->GetFont();
 115
 116     wxASSERT_MSG( window, wxT("DC needs a window") );
 117
 118     GtkWidget *widget = window->m_wxwindow;
 119
 120     wxASSERT_MSG( widget, wxT("DC needs a widget") );
 121
 122     GtkMyFixed *myfixed = GTK_MYFIXED( widget );
 123     m_window = myfixed->bin_window;
 124
 125     /* not realized ? */
 126     if (!m_window)
 127     {
 128          /* don't report problems */
 129          m_ok = TRUE;
 130
 131          return;
 132     }
 133
 134     if (window->m_wxwindow)
 135         m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
 136     else
 137         m_cmap = gtk_widget_get_colormap( window->m_widget );
 138
 139     SetUpDC();
 140
 141     /* this must be done after SetUpDC, bacause SetUpDC calls the
 142        repective SetBrush, SetPen, SetBackground etc functions
 143        to set up the DC. SetBackground call m_owner->SetBackground
 144        and this might not be desired as the standard dc background
 145        is white whereas a window might assume gray to be the
 146        standard (as e.g. wxStatusBar) */
 147
 148     m_owner = window;
 149 }
 150
 151 wxWindowDC::~wxWindowDC()
 152 {
 153     Destroy();
 154 }
 155
 156 void wxWindowDC::DoFloodFill( long WXUNUSED(x), long WXUNUSED(y),
 157                            const wxColour &WXUNUSED(col), int WXUNUSED(style) )
 158 {
 159     wxFAIL_MSG( wxT("wxWindowDC::DoFloodFill not implemented") );
 160 }
 161
 162 bool wxWindowDC::DoGetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
 163 {
 164     wxFAIL_MSG( wxT("wxWindowDC::DoGetPixel not implemented") );
 165     return FALSE;
 166 }
 167
 168 void wxWindowDC::DoDrawLine( long x1, long y1, long x2, long y2 )
 169 {
 170     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 171
 172     if (m_pen.GetStyle() != wxTRANSPARENT)
 173     {
 174         if (m_window)
 175             gdk_draw_line( m_window, m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
 176
 177         CalcBoundingBox(x1, y1);
 178         CalcBoundingBox(x2, y2);
 179     }
 180 }
 181
 182 void wxWindowDC::DoCrossHair( long x, long y )
 183 {
 184     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 185
 186     if (m_pen.GetStyle() != wxTRANSPARENT)
 187     {
 188         int w = 0;
 189         int h = 0;
 190         GetSize( &w, &h );
 191         long xx = XLOG2DEV(x);
 192         long yy = YLOG2DEV(y);
 193         if (m_window)
 194         {
 195             gdk_draw_line( m_window, m_penGC, 0, yy, XLOG2DEVREL(w), yy );
 196             gdk_draw_line( m_window, m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
 197         }
 198     }
 199 }
 200
 201 void wxWindowDC::DoDrawArc( long x1, long y1, long x2, long y2,
 202                             long xc, long yc )
 203 {
 204     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 205
 206     long xx1 = XLOG2DEV(x1);
 207     long yy1 = YLOG2DEV(y1);
 208     long xx2 = XLOG2DEV(x2);
 209     long yy2 = YLOG2DEV(y2);
 210     long xxc = XLOG2DEV(xc);
 211     long yyc = YLOG2DEV(yc);
 212     double dx = xx1 - xxc;
 213     double dy = yy1 - yyc;
 214     double radius = sqrt((double)(dx*dx+dy*dy));
 215     long   r      = (long)radius;
 216     double radius1, radius2;
 217
 218     if (xx1 == xx2 && yy1 == yy2)
 219     {
 220         radius1 = 0.0;
 221         radius2 = 360.0;
 222     }
 223     else
 224     if (radius == 0.0)
 225     {
 226         radius1 = radius2 = 0.0;
 227     }
 228     else
 229     {
 230         radius1 = (xx1 - xxc == 0) ?
 231             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 232             -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
 233         radius2 = (xx2 - xxc == 0) ?
 234             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 235             -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
 236     }
 237     long alpha1 = long(radius1 * 64.0);
 238     long alpha2 = long((radius2 - radius1) * 64.0);
 239     while (alpha2 <= 0) alpha2 += 360*64;
 240     while (alpha1 > 360*64) alpha1 -= 360*64;
 241
 242     if (m_window)
 243     {
 244         if (m_brush.GetStyle() != wxTRANSPARENT)
 245             gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 246
 247         if (m_pen.GetStyle() != wxTRANSPARENT)
 248             gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 249     }
 250
 251     CalcBoundingBox (x1, y1);
 252     CalcBoundingBox (x2, y2);
 253 }
 254
 255 void wxWindowDC::DoDrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
 256 {
 257     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 258
 259     long xx = XLOG2DEV(x);
 260     long yy = YLOG2DEV(y);
 261     long ww = m_signX * XLOG2DEVREL(width);
 262     long hh = m_signY * YLOG2DEVREL(height);
 263
 264     // CMB: handle -ve width and/or height
 265     if (ww < 0) { ww = -ww; xx = xx - ww; }
 266     if (hh < 0) { hh = -hh; yy = yy - hh; }
 267
 268     if (m_window)
 269     {
 270         long start = long(sa * 64.0);
 271         long end = long(ea * 64.0);
 272
 273         if (m_brush.GetStyle() != wxTRANSPARENT)
 274             gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
 275
 276         if (m_pen.GetStyle() != wxTRANSPARENT)
 277             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
 278     }
 279
 280     CalcBoundingBox (x, y);
 281     CalcBoundingBox (x + width, y + height);
 282 }
 283
 284 void wxWindowDC::DoDrawPoint( long x, long y )
 285 {
 286     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 287
 288     if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
 289         gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 290
 291     CalcBoundingBox (x, y);
 292 }
 293
 294 void wxWindowDC::DoDrawLines( int n, wxPoint points[], long xoffset, long yoffset )
 295 {
 296     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 297
 298     if (m_pen.GetStyle() == wxTRANSPARENT) return;
 299     if (n <= 0) return;
 300
 301     CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
 302
 303     for (int i = 0; i < n-1; i++)
 304     {
 305         long x1 = XLOG2DEV(points[i].x + xoffset);
 306         long x2 = XLOG2DEV(points[i+1].x + xoffset);
 307         long y1 = YLOG2DEV(points[i].y + yoffset);     // oh, what a waste
 308         long y2 = YLOG2DEV(points[i+1].y + yoffset);
 309
 310         if (m_window)
 311             gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
 312
 313         CalcBoundingBox( points[i+1].x + xoffset, points[i+1].y + yoffset );
 314     }
 315 }
 316
 317 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle) )
 318 {
 319     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 320
 321     if (n <= 0) return;
 322
 323     GdkPoint *gdkpoints = new GdkPoint[n+1];
 324     int i;
 325     for (i = 0 ; i < n ; i++)
 326     {
 327         gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
 328         gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
 329
 330         CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
 331     }
 332
 333     if ((m_brush.GetStyle() != wxTRANSPARENT) && m_window)
 334         gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
 335
 336     // To do: Fillstyle
 337
 338     if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
 339     {
 340         for (i = 0 ; i < n ; i++)
 341         {
 342             gdk_draw_line( m_window, m_penGC,
 343                            gdkpoints[i%n].x,
 344                            gdkpoints[i%n].y,
 345                            gdkpoints[(i+1)%n].x,
 346                            gdkpoints[(i+1)%n].y);
 347         }
 348     }
 349
 350     delete[] gdkpoints;
 351 }
 352
 353 void wxWindowDC::DoDrawRectangle( long x, long y, long width, long height )
 354 {
 355     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 356
 357     long xx = XLOG2DEV(x);
 358     long yy = YLOG2DEV(y);
 359     long ww = m_signX * XLOG2DEVREL(width);
 360     long hh = m_signY * YLOG2DEVREL(height);
 361
 362     // CMB: draw nothing if transformed w or h is 0
 363     if (ww == 0 || hh == 0) return;
 364
 365     // CMB: handle -ve width and/or height
 366     if (ww < 0) { ww = -ww; xx = xx - ww; }
 367     if (hh < 0) { hh = -hh; yy = yy - hh; }
 368
 369     if (m_window)
 370     {
 371         if (m_brush.GetStyle() != wxTRANSPARENT)
 372             gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
 373
 374         if (m_pen.GetStyle() != wxTRANSPARENT)
 375             gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
 376     }
 377
 378     CalcBoundingBox( x, y );
 379     CalcBoundingBox( x + width, y + height );
 380 }
 381
 382 void wxWindowDC::DoDrawRoundedRectangle( long x, long y, long width, long height, double radius )
 383 {
 384     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 385
 386     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
 387
 388     long xx = XLOG2DEV(x);
 389     long yy = YLOG2DEV(y);
 390     long ww = m_signX * XLOG2DEVREL(width);
 391     long hh = m_signY * YLOG2DEVREL(height);
 392     long rr = XLOG2DEVREL((long)radius);
 393
 394     // CMB: handle -ve width and/or height
 395     if (ww < 0) { ww = -ww; xx = xx - ww; }
 396     if (hh < 0) { hh = -hh; yy = yy - hh; }
 397
 398     // CMB: if radius is zero use DrawRectangle() instead to avoid
 399     // X drawing errors with small radii
 400     if (rr == 0)
 401     {
 402         DrawRectangle( x, y, width, height );
 403         return;
 404     }
 405
 406     // CMB: draw nothing if transformed w or h is 0
 407     if (ww == 0 || hh == 0) return;
 408
 409     // CMB: adjust size if outline is drawn otherwise the result is
 410     // 1 pixel too wide and high
 411     if (m_pen.GetStyle() != wxTRANSPARENT)
 412     {
 413         ww--;
 414         hh--;
 415     }
 416
 417     if (m_window)
 418     {
 419         // CMB: ensure dd is not larger than rectangle otherwise we
 420         // get an hour glass shape
 421         long dd = 2 * rr;
 422         if (dd > ww) dd = ww;
 423         if (dd > hh) dd = hh;
 424         rr = dd / 2;
 425
 426         if (m_brush.GetStyle() != wxTRANSPARENT)
 427         {
 428             gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 429             gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 430             gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 431             gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 432             gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 433             gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 434         }
 435
 436         if (m_pen.GetStyle() != wxTRANSPARENT)
 437         {
 438             gdk_draw_line( m_window, m_penGC, xx+rr, yy, xx+ww-rr, yy );
 439             gdk_draw_line( m_window, m_penGC, xx+rr, yy+hh, xx+ww-rr, yy+hh );
 440             gdk_draw_line( m_window, m_penGC, xx, yy+rr, xx, yy+hh-rr );
 441             gdk_draw_line( m_window, m_penGC, xx+ww, yy+rr, xx+ww, yy+hh-rr );
 442             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, dd, dd, 90*64, 90*64 );
 443             gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 444             gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 445             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 446         }
 447     }
 448
 449     // this ignores the radius
 450     CalcBoundingBox( x, y );
 451     CalcBoundingBox( x + width, y + height );
 452 }
 453
 454 void wxWindowDC::DoDrawEllipse( long x, long y, long width, long height )
 455 {
 456     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 457
 458     long xx = XLOG2DEV(x);
 459     long yy = YLOG2DEV(y);
 460     long ww = m_signX * XLOG2DEVREL(width);
 461     long hh = m_signY * YLOG2DEVREL(height);
 462
 463     // CMB: handle -ve width and/or height
 464     if (ww < 0) { ww = -ww; xx = xx - ww; }
 465     if (hh < 0) { hh = -hh; yy = yy - hh; }
 466
 467     if (m_window)
 468     {
 469         if (m_brush.GetStyle() != wxTRANSPARENT)
 470             gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
 471
 472         if (m_pen.GetStyle() != wxTRANSPARENT)
 473             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
 474     }
 475
 476     CalcBoundingBox( x - width, y - height );
 477     CalcBoundingBox( x + width, y + height );
 478 }
 479
 480 void wxWindowDC::DoDrawIcon( const wxIcon &icon, long x, long y )
 481 {
 482     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
 483     DoDrawBitmap( (const wxBitmap&)icon, x, y, (bool)TRUE );
 484 }
 485
 486 void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
 487                                long x, long y,
 488                                bool useMask )
 489 {
 490     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 491
 492     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
 493
 494     /* scale/translate size and position */
 495
 496     int xx = XLOG2DEV(x);
 497     int yy = YLOG2DEV(y);
 498
 499     int w = bitmap.GetWidth();
 500     int h = bitmap.GetHeight();
 501
 502     CalcBoundingBox( x, y );
 503     CalcBoundingBox( x + w, y + h );
 504
 505     if (!m_window) return;
 506
 507     int ww = XLOG2DEVREL(w);
 508     int hh = YLOG2DEVREL(h);
 509
 510     /* scale bitmap if required */
 511
 512     wxBitmap use_bitmap;
 513
 514     if ((w != ww) || (h != hh))
 515     {
 516         wxImage image( bitmap );
 517         image = image.Scale( ww, hh );
 518
 519         use_bitmap = image.ConvertToBitmap();
 520     }
 521     else
 522     {
 523         use_bitmap = bitmap;
 524     }
 525
 526     /* apply mask if any */
 527
 528     GdkBitmap *mask = (GdkBitmap *) NULL;
 529     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
 530
 531     if (useMask && mask)
 532     {
 533         gdk_gc_set_clip_mask( m_penGC, mask );
 534         gdk_gc_set_clip_origin( m_penGC, xx, yy );
 535     }
 536
 537     /* draw XPixmap or XBitmap, depending on what the wxBitmap contains */
 538
 539     GdkPixmap *pm = use_bitmap.GetPixmap();
 540     if (pm)
 541     {
 542         gdk_draw_pixmap( m_window, m_penGC, pm, 0, 0, xx, yy, -1, -1 );
 543     }
 544     else
 545     {
 546         GdkBitmap *bm = use_bitmap.GetBitmap();
 547         if (bm)
 548         {
 549             gdk_draw_bitmap( m_window, m_penGC, bm, 0, 0, xx, yy, -1, -1 );
 550         }
 551     }
 552
 553     /* remove mask again if any */
 554
 555     if (useMask && mask)
 556     {
 557         gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
 558         gdk_gc_set_clip_origin( m_penGC, 0, 0 );
 559     }
 560 }
 561
 562 bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
 563                          wxDC *source, long xsrc, long ysrc,
 564                          int logical_func, bool useMask )
 565 {
 566    /* this is the nth try to get this utterly useless function to
 567       work. it now completely ignores the scaling or translation
 568       of the source dc, but scales correctly on the target dc and
 569       knows about possible mask information in a memory dc. */
 570
 571     wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
 572
 573     wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
 574
 575     if (!m_window) return FALSE;
 576
 577     wxClientDC *srcDC = (wxClientDC*)source;
 578     wxMemoryDC *memDC = (wxMemoryDC*)source;
 579
 580     bool use_bitmap_method = FALSE;
 581
 582     if (srcDC->m_isMemDC)
 583     {
 584         if (!memDC->m_selected.Ok()) return FALSE;
 585
 586         /* we use the "XCopyArea" way to copy a memory dc into
 587            y different window if the memory dc BOTH
 588            a) doesn't have any mask or its mask isn't used
 589            b) it is clipped
 590            c) is not 1-bit */
 591
 592         if (useMask && (memDC->m_selected.GetMask()))
 593         {
 594            /* we HAVE TO use the direct way for memory dcs
 595               that have mask since the XCopyArea doesn't know
 596               about masks */
 597             use_bitmap_method = TRUE;
 598         }
 599         else if (memDC->m_selected.GetDepth() == 1)
 600         {
 601            /* we HAVE TO use the direct way for memory dcs
 602               that are bitmaps because XCopyArea doesn't cope
 603               with different bit depths */
 604             use_bitmap_method = TRUE;
 605         }
 606         else if ((xsrc == 0) && (ysrc == 0) &&
 607                  (width == memDC->m_selected.GetWidth()) &&
 608                  (height == memDC->m_selected.GetHeight()))
 609         {
 610            /* we SHOULD use the direct way if all of the bitmap
 611               in the memory dc is copied in which case XCopyArea
 612               wouldn't be able able to boost performace by reducing
 613               the area to be scaled */
 614             use_bitmap_method = TRUE;
 615         }
 616         else
 617         {
 618             use_bitmap_method = FALSE;
 619         }
 620     }
 621
 622     CalcBoundingBox( xdest, ydest );
 623     CalcBoundingBox( xdest + width, ydest + height );
 624
 625     int old_logical_func = m_logicalFunction;
 626     SetLogicalFunction( logical_func );
 627
 628     if (use_bitmap_method)
 629     {
 630         /* scale/translate bitmap size */
 631
 632         long bm_width = memDC->m_selected.GetWidth();
 633         long bm_height = memDC->m_selected.GetHeight();
 634
 635         long bm_ww = XLOG2DEVREL( bm_width );
 636         long bm_hh = YLOG2DEVREL( bm_height );
 637
 638         /* scale bitmap if required */
 639
 640         wxBitmap use_bitmap;
 641
 642         if ((bm_width != bm_ww) || (bm_height != bm_hh))
 643         {
 644             wxImage image( memDC->m_selected );
 645             image = image.Scale( bm_ww, bm_hh );
 646
 647             use_bitmap = image.ConvertToBitmap();
 648         }
 649         else
 650         {
 651             use_bitmap = memDC->m_selected;
 652         }
 653
 654         /* scale/translate size and position */
 655
 656         long xx = XLOG2DEV(xdest);
 657         long yy = YLOG2DEV(ydest);
 658
 659         long ww = XLOG2DEVREL(width);
 660         long hh = YLOG2DEVREL(height);
 661
 662         /* apply mask if any */
 663
 664         GdkBitmap *mask = (GdkBitmap *) NULL;
 665         if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
 666
 667         if (useMask && mask)
 668         {
 669             gdk_gc_set_clip_mask( m_penGC, mask );
 670             gdk_gc_set_clip_origin( m_penGC, xx, yy );
 671         }
 672
 673         /* draw XPixmap or XBitmap, depending on what the wxBitmap contains */
 674
 675         GdkPixmap *pm = use_bitmap.GetPixmap();
 676         if (pm)
 677         {
 678             gdk_draw_pixmap( m_window, m_penGC, pm, xsrc, ysrc, xx, yy, ww, hh );
 679         }
 680         else
 681         {
 682             GdkBitmap *bm = use_bitmap.GetBitmap();
 683             if (bm)
 684             {
 685                 /* we use the textGC here because blitting a bitmap is done
 686                    using the current text colour */
 687                 gdk_draw_bitmap( m_window, m_textGC, bm, xsrc, ysrc, xx, yy, ww, hh );
 688             }
 689         }
 690
 691         /* remove mask again if any */
 692
 693         if (useMask && mask)
 694         {
 695             gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
 696             gdk_gc_set_clip_origin( m_penGC, 0, 0 );
 697         }
 698     }
 699     else /* use_bitmap_method */
 700     {
 701         /* scale/translate size and position */
 702
 703         long xx = XLOG2DEV(xdest);
 704         long yy = YLOG2DEV(ydest);
 705
 706         long ww = XLOG2DEVREL(width);
 707         long hh = YLOG2DEVREL(height);
 708
 709         if ((width != ww) || (height != hh))
 710         {
 711             /* draw source window into a bitmap as we cannot scale
 712                a window in contrast to a bitmap. this would actually
 713                work with memory dcs as well, but we'd lose the mask
 714                information and waste one step in this process since
 715                a memory already has a bitmap. all this is slightly
 716                inefficient as we could take an XImage directly from
 717                an X window, but we'd then also have to care that
 718                the window is not outside the screen (in which case
 719                we'd get a BadMatch or what not).
 720                Is a double XGetImage and combined XGetPixel and
 721                XPutPixel really faster? I'm not sure. look at wxXt
 722                for a different implementation of the same problem. */
 723
 724             wxBitmap bitmap( width, height );
 725             gdk_window_copy_area( bitmap.GetPixmap(), m_penGC, 0, 0,
 726                                   srcDC->GetWindow(),
 727                                   xsrc, ysrc, width, height );
 728
 729             /* scale image */
 730
 731             wxImage image( bitmap );
 732             image = image.Scale( ww, hh );
 733
 734             /* convert to bitmap */
 735
 736             bitmap = image.ConvertToBitmap();
 737
 738             /* draw scaled bitmap */
 739
 740             gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
 741
 742         }
 743         else
 744         {
 745             /* no scaling and not a memory dc with a mask either */
 746
 747             gdk_window_copy_area( m_window, m_penGC, xx, yy,
 748                                   srcDC->GetWindow(),
 749                                   xsrc, ysrc, width, height );
 750         }
 751     }
 752
 753     SetLogicalFunction( old_logical_func );
 754     return TRUE;
 755 }
 756
 757 void wxWindowDC::DoDrawText( const wxString &text, long x, long y )
 758 {
 759     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 760
 761     if (!m_window) return;
 762
 763     GdkFont *font = m_font.GetInternalFont( m_scaleY );
 764
 765     x = XLOG2DEV(x);
 766     y = YLOG2DEV(y);
 767
 768     /* CMB 21/5/98: draw text background if mode is wxSOLID */
 769     if (m_backgroundMode == wxSOLID)
 770     {
 771         long width = gdk_string_width( font, text.mbc_str() );
 772         long height = font->ascent + font->descent;
 773         gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
 774         gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
 775         gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
 776     }
 777     gdk_draw_string( m_window, font, m_textGC, x, y + font->ascent, text.mbc_str() );
 778
 779     /* CMB 17/7/98: simple underline: ignores scaling and underlying
 780        X font's XA_UNDERLINE_POSITION and XA_UNDERLINE_THICKNESS
 781        properties (see wxXt implementation) */
 782     if (m_font.GetUnderlined())
 783     {
 784         long width = gdk_string_width( font, text.mbc_str() );
 785         long ul_y = y + font->ascent;
 786         if (font->descent > 0) ul_y++;
 787         gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
 788     }
 789
 790     long w, h;
 791     GetTextExtent (text, &w, &h);
 792     CalcBoundingBox (x + w, y + h);
 793     CalcBoundingBox (x, y);
 794 }
 795
 796 void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
 797                                 long *descent, long *externalLeading,
 798                                 wxFont *theFont ) const
 799 {
 800     wxFont fontToUse = m_font;
 801     if (theFont) fontToUse = *theFont;
 802
 803     GdkFont *font = fontToUse.GetInternalFont( m_scaleY );
 804     if (width) (*width) = long(gdk_string_width( font, string.mbc_str() ) / m_scaleX);
 805     if (height) (*height) = long((font->ascent + font->descent) / m_scaleY);
 806     if (descent) (*descent) = long(font->descent / m_scaleY);
 807     if (externalLeading) (*externalLeading) = 0;  // ??
 808 }
 809
 810 long wxWindowDC::GetCharWidth() const
 811 {
 812     GdkFont *font = m_font.GetInternalFont( m_scaleY );
 813     return long(gdk_string_width( font, "H" ) / m_scaleX);
 814 }
 815
 816 long wxWindowDC::GetCharHeight() const
 817 {
 818     GdkFont *font = m_font.GetInternalFont( m_scaleY );
 819     return long((font->ascent + font->descent) / m_scaleY);
 820 }
 821
 822 void wxWindowDC::Clear()
 823 {
 824     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 825
 826     if (!m_window) return;
 827
 828     /* - we either are a memory dc or have a window as the
 829        owner. anything else shouldn't happen.
 830        - we don't use gdk_window_clear() as we don't set
 831        the window's background colour anymore. it is too
 832        much pain to keep the DC's and the window's back-
 833        ground colour in synch. */
 834
 835     if (m_owner)
 836     {
 837         int width,height;
 838         m_owner->GetSize( &width, &height );
 839         gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
 840         return;
 841     }
 842
 843     if (m_isMemDC)
 844     {
 845         int width,height;
 846         GetSize( &width, &height );
 847         gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
 848         return;
 849     }
 850 }
 851
 852 void wxWindowDC::SetFont( const wxFont &font )
 853 {
 854     m_font = font;
 855 }
 856
 857 void wxWindowDC::SetPen( const wxPen &pen )
 858 {
 859     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 860
 861     if (m_pen == pen) return;
 862
 863     m_pen = pen;
 864
 865     if (!m_pen.Ok()) return;
 866
 867     if (!m_window) return;
 868
 869     gint width = m_pen.GetWidth();
 870     if (width <= 0)
 871     {
 872         // CMB: if width is non-zero scale it with the dc
 873         width = 1;
 874     }
 875     else
 876     {
 877         // X doesn't allow different width in x and y and so we take
 878         // the average
 879         double w = 0.5 +
 880                    ( fabs((double) XLOG2DEVREL(width)) +
 881                      fabs((double) YLOG2DEVREL(width)) ) / 2.0;
 882         width = (int)w;
 883     }
 884
 885     static const char dotted[] = {1, 1};
 886     static const char short_dashed[] = {2, 2};
 887     static const char long_dashed[] = {2, 4};
 888     static const char dotted_dashed[] = {3, 3, 1, 3};
 889
 890     // We express dash pattern in pen width unit, so we are
 891     // independent of zoom factor and so on...
 892     int req_nb_dash;
 893     const char *req_dash;
 894
 895     GdkLineStyle lineStyle = GDK_LINE_SOLID;
 896     switch (m_pen.GetStyle())
 897     {
 898         case wxUSER_DASH:
 899         {
 900             lineStyle = GDK_LINE_ON_OFF_DASH;
 901             req_nb_dash = m_pen.GetDashCount();
 902             req_dash = m_pen.GetDash();
 903             break;
 904         }
 905         case wxDOT:
 906         {
 907             lineStyle = GDK_LINE_ON_OFF_DASH;
 908             req_nb_dash = 2;
 909             req_dash = dotted;
 910             break;
 911         }
 912         case wxLONG_DASH:
 913         {
 914             lineStyle = GDK_LINE_ON_OFF_DASH;
 915             req_nb_dash = 2;
 916             req_dash = long_dashed;
 917             break;
 918         }
 919         case wxSHORT_DASH:
 920         {
 921             lineStyle = GDK_LINE_ON_OFF_DASH;
 922             req_nb_dash = 2;
 923             req_dash = short_dashed;
 924             break;
 925         }
 926         case wxDOT_DASH:
 927         {
 928 //            lineStyle = GDK_LINE_DOUBLE_DASH;
 929             lineStyle = GDK_LINE_ON_OFF_DASH;
 930             req_nb_dash = 4;
 931             req_dash = dotted_dashed;
 932             break;
 933         }
 934
 935         case wxTRANSPARENT:
 936         case wxSTIPPLE:
 937         case wxSOLID:
 938         default:
 939         {
 940             lineStyle = GDK_LINE_SOLID;
 941             req_dash = (wxDash*)NULL;
 942             req_nb_dash = 0;
 943             break;
 944         }
 945     }
 946
 947 #if (GTK_MINOR_VERSION > 0)
 948     if (req_dash && req_nb_dash)
 949     {
 950         char *real_req_dash = new char[req_nb_dash];
 951         if (real_req_dash)
 952         {
 953             for (int i = 0; i < req_nb_dash; i++)
 954                 real_req_dash[i] = req_dash[i] * width;
 955             gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
 956             delete[] real_req_dash;
 957         }
 958         else
 959         {
 960             // No Memory. We use non-scaled dash pattern...
 961             gdk_gc_set_dashes( m_penGC, 0, (char*)req_dash, req_nb_dash );
 962         }
 963     }
 964 #endif
 965
 966     GdkCapStyle capStyle = GDK_CAP_ROUND;
 967     switch (m_pen.GetCap())
 968     {
 969         case wxCAP_ROUND:      { capStyle = (width <= 1) ? GDK_CAP_NOT_LAST : GDK_CAP_ROUND; break; }
 970         case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
 971         case wxCAP_BUTT:       { capStyle = GDK_CAP_BUTT;       break; }
 972     }
 973
 974     GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
 975     switch (m_pen.GetJoin())
 976     {
 977         case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
 978         case wxJOIN_ROUND: { joinStyle = GDK_JOIN_ROUND; break; }
 979         case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
 980     }
 981
 982     gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
 983
 984     m_pen.GetColour().CalcPixel( m_cmap );
 985     gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
 986 }
 987
 988 void wxWindowDC::SetBrush( const wxBrush &brush )
 989 {
 990     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 991
 992     if (m_brush == brush) return;
 993
 994     m_brush = brush;
 995
 996     if (!m_brush.Ok()) return;
 997
 998     if (!m_window) return;
 999
1000     m_brush.GetColour().CalcPixel( m_cmap );
1001     gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
1002
1003     gdk_gc_set_fill( m_brushGC, GDK_SOLID );
1004
1005     if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1006     {
1007         if (m_brush.GetStipple()->GetPixmap())
1008         {
1009             gdk_gc_set_fill( m_brushGC, GDK_TILED );
1010             gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
1011         }
1012         else
1013         {
1014             gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1015             gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetBitmap() );
1016         }
1017     }
1018
1019     if (IS_HATCH(m_brush.GetStyle()))
1020     {
1021         gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1022         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1023         gdk_gc_set_stipple( m_brushGC, hatches[num] );
1024     }
1025 }
1026
1027 void wxWindowDC::SetBackground( const wxBrush &brush )
1028 {
1029    /* CMB 21/7/98: Added SetBackground. Sets background brush
1030     * for Clear() and bg colour for shapes filled with cross-hatch brush */
1031
1032     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1033
1034     if (m_backgroundBrush == brush) return;
1035
1036     m_backgroundBrush = brush;
1037
1038     if (!m_backgroundBrush.Ok()) return;
1039
1040     if (!m_window) return;
1041
1042     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1043     gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
1044     gdk_gc_set_background( m_penGC, m_backgroundBrush.GetColour().GetColor() );
1045     gdk_gc_set_background( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1046     gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1047
1048     gdk_gc_set_fill( m_bgGC, GDK_SOLID );
1049
1050     if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1051     {
1052         if (m_backgroundBrush.GetStipple()->GetPixmap())
1053         {
1054             gdk_gc_set_fill( m_bgGC, GDK_TILED );
1055             gdk_gc_set_tile( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
1056         }
1057         else
1058         {
1059             gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1060             gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetBitmap() );
1061         }
1062     }
1063
1064     if (IS_HATCH(m_backgroundBrush.GetStyle()))
1065     {
1066         gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1067         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1068         gdk_gc_set_stipple( m_bgGC, hatches[num] );
1069     }
1070 }
1071
1072 void wxWindowDC::SetLogicalFunction( int function )
1073 {
1074     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1075
1076     if (m_logicalFunction == function) return;
1077
1078     GdkFunction mode = GDK_COPY;
1079     switch (function)
1080     {
1081         case wxXOR:          mode = GDK_XOR;           break;
1082         case wxINVERT:       mode = GDK_INVERT;        break;
1083 #if (GTK_MINOR_VERSION > 0)
1084         case wxOR_REVERSE:   mode = GDK_OR_REVERSE;    break;
1085         case wxAND_REVERSE:  mode = GDK_AND_REVERSE;   break;
1086         case wxCLEAR:        mode = GDK_CLEAR;         break;
1087         case wxSET:          mode = GDK_SET;           break;
1088         case wxOR_INVERT:    mode = GDK_OR_INVERT;     break;
1089         case wxSRC_AND:
1090         case wxAND:          mode = GDK_AND;           break;
1091         case wxSRC_OR:
1092         case wxOR:           mode = GDK_OR;            break;
1093         case wxEQUIV:        mode = GDK_EQUIV;         break;
1094         case wxNAND:         mode = GDK_NAND;          break;
1095         case wxAND_INVERT:   mode = GDK_AND_INVERT;    break;
1096         case wxCOPY:         mode = GDK_COPY;          break;
1097         case wxNO_OP:        mode = GDK_NOOP;          break;
1098         case wxSRC_INVERT:   mode = GDK_COPY_INVERT;   break;
1099 #endif
1100         default:
1101         {
1102            wxFAIL_MSG( wxT("unsupported logical function") );
1103            break;
1104         }
1105     }
1106
1107     m_logicalFunction = function;
1108
1109     if (!m_window) return;
1110
1111     gdk_gc_set_function( m_penGC, mode );
1112     gdk_gc_set_function( m_brushGC, mode );
1113     gdk_gc_set_function( m_textGC, mode );
1114 }
1115
1116 void wxWindowDC::SetTextForeground( const wxColour &col )
1117 {
1118     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1119
1120     if (m_textForegroundColour == col) return;
1121
1122     m_textForegroundColour = col;
1123     if (!m_textForegroundColour.Ok()) return;
1124
1125     if (!m_window) return;
1126
1127     m_textForegroundColour.CalcPixel( m_cmap );
1128     gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1129 }
1130
1131 void wxWindowDC::SetTextBackground( const wxColour &col )
1132 {
1133     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1134
1135     if (m_textBackgroundColour == col) return;
1136
1137     m_textBackgroundColour = col;
1138     if (!m_textBackgroundColour.Ok()) return;
1139
1140     if (!m_window) return;
1141
1142     m_textBackgroundColour.CalcPixel( m_cmap );
1143     gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
1144 }
1145
1146 void wxWindowDC::SetBackgroundMode( int mode )
1147 {
1148     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1149
1150     m_backgroundMode = mode;
1151
1152     if (!m_window) return;
1153
1154     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1155     // transparent/solid background mode
1156
1157     if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1158     {
1159         gdk_gc_set_fill( m_brushGC,
1160           (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
1161     }
1162 }
1163
1164 void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
1165 {
1166     wxFAIL_MSG( wxT("wxWindowDC::SetPalette not implemented") );
1167 }
1168
1169 void wxWindowDC::DoSetClippingRegion( long x, long y, long width, long height )
1170 {
1171     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1172
1173     wxDC::DoSetClippingRegion( x, y, width, height );
1174
1175     if (!m_window) return;
1176
1177     GdkRectangle rect;
1178     rect.x = XLOG2DEV(x);
1179     rect.y = YLOG2DEV(y);
1180     rect.width = XLOG2DEVREL(width);
1181     rect.height = YLOG2DEVREL(height);
1182     gdk_gc_set_clip_rectangle( m_penGC, &rect );
1183     gdk_gc_set_clip_rectangle( m_brushGC, &rect );
1184     gdk_gc_set_clip_rectangle( m_textGC, &rect );
1185     gdk_gc_set_clip_rectangle( m_bgGC, &rect );
1186 }
1187
1188 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion &region  )
1189 {
1190     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1191
1192     if (region.Empty())
1193     {
1194         DestroyClippingRegion();
1195         return;
1196     }
1197
1198     if (!m_window) return;
1199
1200     gdk_gc_set_clip_region( m_penGC, region.GetRegion() );
1201     gdk_gc_set_clip_region( m_brushGC, region.GetRegion() );
1202     gdk_gc_set_clip_region( m_textGC, region.GetRegion() );
1203     gdk_gc_set_clip_region( m_bgGC, region.GetRegion() );
1204 }
1205
1206 void wxWindowDC::DestroyClippingRegion()
1207 {
1208     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1209
1210     wxDC::DestroyClippingRegion();
1211
1212     if (!m_window) return;
1213
1214     gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
1215     gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
1216     gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
1217     gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
1218 }
1219
1220 void wxWindowDC::SetUpDC()
1221 {
1222     Destroy();
1223     m_ok = TRUE;
1224     m_logicalFunction = wxCOPY;
1225     m_penGC = gdk_gc_new( m_window );
1226     m_brushGC = gdk_gc_new( m_window );
1227     m_textGC = gdk_gc_new( m_window );
1228     m_bgGC = gdk_gc_new( m_window );
1229
1230     wxColour tmp_col( m_textForegroundColour );
1231     m_textForegroundColour = wxNullColour;
1232     SetTextForeground( tmp_col );
1233     tmp_col = m_textBackgroundColour;
1234     m_textBackgroundColour = wxNullColour;
1235     SetTextBackground( tmp_col );
1236
1237     wxPen tmp_pen( m_pen );
1238     m_pen = wxNullPen;
1239     SetPen( tmp_pen );
1240
1241     wxFont tmp_font( m_font );
1242     m_font = wxNullFont;
1243     SetFont( tmp_font );
1244
1245     wxBrush tmp_brush( m_brush );
1246     m_brush = wxNullBrush;
1247     SetBrush( tmp_brush );
1248
1249 /*
1250     tmp_brush = m_backgroundBrush;
1251     m_backgroundBrush = wxNullBrush;
1252     SetBackground( tmp_brush );
1253 */
1254     tmp_brush = m_backgroundBrush;
1255     m_backgroundBrush = wxNullBrush;
1256     SetBackground( *wxWHITE_BRUSH );
1257     m_backgroundBrush = tmp_brush;
1258
1259     if (!hatch_bitmap)
1260     {
1261         hatch_bitmap    = hatches;
1262         hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
1263         hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
1264         hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
1265         hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
1266         hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
1267         hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
1268     }
1269 }
1270
1271 void wxWindowDC::Destroy()
1272 {
1273     if (m_penGC) gdk_gc_unref( m_penGC );
1274     m_penGC = (GdkGC*) NULL;
1275     if (m_brushGC) gdk_gc_unref( m_brushGC );
1276     m_brushGC = (GdkGC*) NULL;
1277     if (m_textGC) gdk_gc_unref( m_textGC );
1278     m_textGC = (GdkGC*) NULL;
1279     if (m_bgGC) gdk_gc_unref( m_bgGC );
1280     m_bgGC = (GdkGC*) NULL;
1281 }
1282
1283 void wxWindowDC::ComputeScaleAndOrigin()
1284 {
1285     /* CMB: copy scale to see if it changes */
1286     double origScaleX = m_scaleX;
1287     double origScaleY = m_scaleY;
1288
1289     wxDC::ComputeScaleAndOrigin();
1290
1291     /* CMB: if scale has changed call SetPen to recalulate the line width */
1292     if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1293         (m_pen.Ok()))
1294     {
1295       /* this is a bit artificial, but we need to force wxDC to think
1296          the pen has changed */
1297       wxPen pen = m_pen;
1298       m_pen = wxNullPen;
1299       SetPen( pen );
1300   }
1301 }
1302
1303 // Resolution in pixels per logical inch
1304 wxSize wxWindowDC::GetPPI() const
1305 {
1306     return wxSize(100, 100);
1307 }
1308
1309 int wxWindowDC::GetDepth() const
1310 {
1311     wxFAIL_MSG(wxT("not implemented"));
1312
1313     return -1;
1314 }
1315
1316 #if wxUSE_SPLINES
1317 // ----------------------------------- spline code ----------------------------------------
1318
1319 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1320                          double a3, double b3, double a4, double b4);
1321 void wx_clear_stack();
1322 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1323         double *y3, double *x4, double *y4);
1324 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1325           double x4, double y4);
1326 static bool wx_spline_add_point(double x, double y);
1327 static void wx_spline_draw_point_array(wxDC *dc);
1328
1329 wxList wx_spline_point_list;
1330
1331 #define                half(z1, z2)        ((z1+z2)/2.0)
1332 #define                THRESHOLD        5
1333
1334 /* iterative version */
1335
1336 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1337                  double b4)
1338 {
1339     register double  xmid, ymid;
1340     double           x1, y1, x2, y2, x3, y3, x4, y4;
1341
1342     wx_clear_stack();
1343     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1344
1345     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1346         xmid = (double)half(x2, x3);
1347         ymid = (double)half(y2, y3);
1348         if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1349             fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1350             wx_spline_add_point( x1, y1 );
1351             wx_spline_add_point( xmid, ymid );
1352         } else {
1353             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1354                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1355             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1356                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1357         }
1358     }
1359 }
1360
1361 /* utilities used by spline drawing routines */
1362
1363 typedef struct wx_spline_stack_struct {
1364     double           x1, y1, x2, y2, x3, y3, x4, y4;
1365 } Stack;
1366
1367 #define         SPLINE_STACK_DEPTH             20
1368 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
1369 static Stack   *wx_stack_top;
1370 static int      wx_stack_count;
1371
1372 void wx_clear_stack()
1373 {
1374     wx_stack_top = wx_spline_stack;
1375     wx_stack_count = 0;
1376 }
1377
1378 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1379 {
1380     wx_stack_top->x1 = x1;
1381     wx_stack_top->y1 = y1;
1382     wx_stack_top->x2 = x2;
1383     wx_stack_top->y2 = y2;
1384     wx_stack_top->x3 = x3;
1385     wx_stack_top->y3 = y3;
1386     wx_stack_top->x4 = x4;
1387     wx_stack_top->y4 = y4;
1388     wx_stack_top++;
1389     wx_stack_count++;
1390 }
1391
1392 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1393                   double *x3, double *y3, double *x4, double *y4)
1394 {
1395     if (wx_stack_count == 0)
1396         return (0);
1397     wx_stack_top--;
1398     wx_stack_count--;
1399     *x1 = wx_stack_top->x1;
1400     *y1 = wx_stack_top->y1;
1401     *x2 = wx_stack_top->x2;
1402     *y2 = wx_stack_top->y2;
1403     *x3 = wx_stack_top->x3;
1404     *y3 = wx_stack_top->y3;
1405     *x4 = wx_stack_top->x4;
1406     *y4 = wx_stack_top->y4;
1407     return (1);
1408 }
1409
1410 static bool wx_spline_add_point(double x, double y)
1411 {
1412   wxPoint *point = new wxPoint ;
1413   point->x = (int) x;
1414   point->y = (int) y;
1415   wx_spline_point_list.Append((wxObject*)point);
1416   return TRUE;
1417 }
1418
1419 static void wx_spline_draw_point_array(wxDC *dc)
1420 {
1421   dc->DrawLines(&wx_spline_point_list, 0, 0 );
1422   wxNode *node = wx_spline_point_list.First();
1423   while (node)
1424   {
1425     wxPoint *point = (wxPoint *)node->Data();
1426     delete point;
1427     delete node;
1428     node = wx_spline_point_list.First();
1429   }
1430 }
1431
1432 void wxWindowDC::DoDrawSpline( wxList *points )
1433 {
1434     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1435
1436     wxPoint *p;
1437     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1438     double           x1, y1, x2, y2;
1439
1440     wxNode *node = points->First();
1441     p = (wxPoint *)node->Data();
1442
1443     x1 = p->x;
1444     y1 = p->y;
1445
1446     node = node->Next();
1447     p = (wxPoint *)node->Data();
1448
1449     x2 = p->x;
1450     y2 = p->y;
1451     cx1 = (double)((x1 + x2) / 2);
1452     cy1 = (double)((y1 + y2) / 2);
1453     cx2 = (double)((cx1 + x2) / 2);
1454     cy2 = (double)((cy1 + y2) / 2);
1455
1456     wx_spline_add_point(x1, y1);
1457
1458     while ((node = node->Next()) != NULL)
1459     {
1460         p = (wxPoint *)node->Data();
1461         x1 = x2;
1462         y1 = y2;
1463         x2 = p->x;
1464         y2 = p->y;
1465         cx4 = (double)(x1 + x2) / 2;
1466         cy4 = (double)(y1 + y2) / 2;
1467         cx3 = (double)(x1 + cx4) / 2;
1468         cy3 = (double)(y1 + cy4) / 2;
1469
1470         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1471
1472         cx1 = cx4;
1473         cy1 = cy4;
1474         cx2 = (double)(cx1 + x2) / 2;
1475         cy2 = (double)(cy1 + y2) / 2;
1476     }
1477
1478     wx_spline_add_point( cx1, cy1 );
1479     wx_spline_add_point( x2, y2 );
1480
1481     wx_spline_draw_point_array( this );
1482 }
1483
1484 #endif // wxUSE_SPLINE
1485
1486 //-----------------------------------------------------------------------------
1487 // wxPaintDC
1488 //-----------------------------------------------------------------------------
1489
1490 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxWindowDC)
1491
1492 wxPaintDC::wxPaintDC()
1493   : wxWindowDC()
1494 {
1495 }
1496
1497 wxPaintDC::wxPaintDC( wxWindow *win )
1498   : wxWindowDC( win )
1499 {
1500 }
1501
1502 //-----------------------------------------------------------------------------
1503 // wxClientDC
1504 //-----------------------------------------------------------------------------
1505
1506 IMPLEMENT_DYNAMIC_CLASS(wxClientDC,wxWindowDC)
1507
1508 wxClientDC::wxClientDC()
1509   : wxWindowDC()
1510 {
1511 }
1512
1513 wxClientDC::wxClientDC( wxWindow *win )
1514   : wxWindowDC( win )
1515 {
1516 }
1517