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