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)
1264         return;
1265
1266     // VZ: shouldn't this be a CHECK?
1267     if (!m_window)
1268         return;
1269
1270     GdkFunction mode = GDK_COPY;
1271     switch (function)
1272     {
1273         case wxXOR:          mode = GDK_XOR;           break;
1274         case wxINVERT:       mode = GDK_INVERT;        break;
1275 #if (GTK_MINOR_VERSION > 0)
1276         case wxOR_REVERSE:   mode = GDK_OR_REVERSE;    break;
1277         case wxAND_REVERSE:  mode = GDK_AND_REVERSE;   break;
1278         case wxCLEAR:        mode = GDK_CLEAR;         break;
1279         case wxSET:          mode = GDK_SET;           break;
1280         case wxOR_INVERT:    mode = GDK_OR_INVERT;     break;
1281         case wxAND:          mode = GDK_AND;           break;
1282         case wxOR:           mode = GDK_OR;            break;
1283         case wxEQUIV:        mode = GDK_EQUIV;         break;
1284         case wxNAND:         mode = GDK_NAND;          break;
1285         case wxAND_INVERT:   mode = GDK_AND_INVERT;    break;
1286         case wxCOPY:         mode = GDK_COPY;          break;
1287         case wxNO_OP:        mode = GDK_NOOP;          break;
1288         case wxSRC_INVERT:   mode = GDK_COPY_INVERT;   break;
1289
1290         // unsupported by GTK
1291         case wxNOR:          mode = GDK_COPY;          break;
1292 #endif
1293         default:
1294         {
1295            wxFAIL_MSG( wxT("unsupported logical function") );
1296            break;
1297         }
1298     }
1299
1300     m_logicalFunction = function;
1301
1302     gdk_gc_set_function( m_penGC, mode );
1303     gdk_gc_set_function( m_brushGC, mode );
1304
1305     // to stay compatible with wxMSW, we don't apply ROPs to the text
1306     // operations (i.e. DrawText/DrawRotatedText)
1307     //  gdk_gc_set_function( m_textGC, mode );
1308 }
1309
1310 void wxWindowDC::SetTextForeground( const wxColour &col )
1311 {
1312     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1313
1314     if (m_textForegroundColour == col) return;
1315
1316     m_textForegroundColour = col;
1317     if (!m_textForegroundColour.Ok()) return;
1318
1319     if (!m_window) return;
1320
1321     m_textForegroundColour.CalcPixel( m_cmap );
1322     gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1323 }
1324
1325 void wxWindowDC::SetTextBackground( const wxColour &col )
1326 {
1327     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1328
1329     if (m_textBackgroundColour == col) return;
1330
1331     m_textBackgroundColour = col;
1332     if (!m_textBackgroundColour.Ok()) return;
1333
1334     if (!m_window) return;
1335
1336     m_textBackgroundColour.CalcPixel( m_cmap );
1337     gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
1338 }
1339
1340 void wxWindowDC::SetBackgroundMode( int mode )
1341 {
1342     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1343
1344     m_backgroundMode = mode;
1345
1346     if (!m_window) return;
1347
1348     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1349     // transparent/solid background mode
1350
1351     if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1352     {
1353         gdk_gc_set_fill( m_brushGC,
1354           (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
1355     }
1356 }
1357
1358 void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
1359 {
1360     wxFAIL_MSG( wxT("wxWindowDC::SetPalette not implemented") );
1361 }
1362
1363 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1364 {
1365     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1366
1367     wxDC::DoSetClippingRegion( x, y, width, height );
1368
1369     if (!m_window) return;
1370
1371     GdkRectangle rect;
1372     rect.x = XLOG2DEV(x);
1373     rect.y = YLOG2DEV(y);
1374     rect.width = XLOG2DEVREL(width);
1375     rect.height = YLOG2DEVREL(height);
1376     gdk_gc_set_clip_rectangle( m_penGC, &rect );
1377     gdk_gc_set_clip_rectangle( m_brushGC, &rect );
1378     gdk_gc_set_clip_rectangle( m_textGC, &rect );
1379     gdk_gc_set_clip_rectangle( m_bgGC, &rect );
1380 }
1381
1382 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion &region  )
1383 {
1384     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1385
1386     if (region.Empty())
1387     {
1388         DestroyClippingRegion();
1389         return;
1390     }
1391
1392     wxCoord x,y,w,h;
1393     region.GetBox( x, y, w, h );
1394
1395     wxDC::DoSetClippingRegion( x, y, w, h );
1396
1397     if (!m_window) return;
1398
1399     gdk_gc_set_clip_region( m_penGC, region.GetRegion() );
1400     gdk_gc_set_clip_region( m_brushGC, region.GetRegion() );
1401     gdk_gc_set_clip_region( m_textGC, region.GetRegion() );
1402     gdk_gc_set_clip_region( m_bgGC, region.GetRegion() );
1403 }
1404
1405 void wxWindowDC::DestroyClippingRegion()
1406 {
1407     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1408
1409     wxDC::DestroyClippingRegion();
1410
1411     if (!m_window) return;
1412
1413     gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
1414     gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
1415     gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
1416     gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
1417 }
1418
1419 void wxWindowDC::SetUpDC()
1420 {
1421     Destroy();
1422     m_ok = TRUE;
1423     m_logicalFunction = wxCOPY;
1424     m_penGC = gdk_gc_new( m_window );
1425     m_brushGC = gdk_gc_new( m_window );
1426     m_textGC = gdk_gc_new( m_window );
1427     m_bgGC = gdk_gc_new( m_window );
1428
1429     wxColour tmp_col( m_textForegroundColour );
1430     m_textForegroundColour = wxNullColour;
1431     SetTextForeground( tmp_col );
1432     tmp_col = m_textBackgroundColour;
1433     m_textBackgroundColour = wxNullColour;
1434     SetTextBackground( tmp_col );
1435
1436     wxPen tmp_pen( m_pen );
1437     m_pen = wxNullPen;
1438     SetPen( tmp_pen );
1439
1440     wxFont tmp_font( m_font );
1441     m_font = wxNullFont;
1442     SetFont( tmp_font );
1443
1444     wxBrush tmp_brush( m_brush );
1445     m_brush = wxNullBrush;
1446     SetBrush( tmp_brush );
1447
1448 /*
1449     tmp_brush = m_backgroundBrush;
1450     m_backgroundBrush = wxNullBrush;
1451     SetBackground( tmp_brush );
1452 */
1453     tmp_brush = m_backgroundBrush;
1454     m_backgroundBrush = wxNullBrush;
1455     SetBackground( *wxWHITE_BRUSH );
1456     m_backgroundBrush = tmp_brush;
1457
1458     if (!hatch_bitmap)
1459     {
1460         hatch_bitmap    = hatches;
1461         hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
1462         hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
1463         hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
1464         hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
1465         hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
1466         hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
1467     }
1468 }
1469
1470 void wxWindowDC::Destroy()
1471 {
1472     if (m_penGC) gdk_gc_unref( m_penGC );
1473     m_penGC = (GdkGC*) NULL;
1474     if (m_brushGC) gdk_gc_unref( m_brushGC );
1475     m_brushGC = (GdkGC*) NULL;
1476     if (m_textGC) gdk_gc_unref( m_textGC );
1477     m_textGC = (GdkGC*) NULL;
1478     if (m_bgGC) gdk_gc_unref( m_bgGC );
1479     m_bgGC = (GdkGC*) NULL;
1480 }
1481
1482 void wxWindowDC::ComputeScaleAndOrigin()
1483 {
1484     /* CMB: copy scale to see if it changes */
1485     double origScaleX = m_scaleX;
1486     double origScaleY = m_scaleY;
1487
1488     wxDC::ComputeScaleAndOrigin();
1489
1490     /* CMB: if scale has changed call SetPen to recalulate the line width */
1491     if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1492         (m_pen.Ok()))
1493     {
1494       /* this is a bit artificial, but we need to force wxDC to think
1495          the pen has changed */
1496       wxPen pen = m_pen;
1497       m_pen = wxNullPen;
1498       SetPen( pen );
1499   }
1500 }
1501
1502 // Resolution in pixels per logical inch
1503 wxSize wxWindowDC::GetPPI() const
1504 {
1505     return wxSize(100, 100);
1506 }
1507
1508 int wxWindowDC::GetDepth() const
1509 {
1510     wxFAIL_MSG(wxT("not implemented"));
1511
1512     return -1;
1513 }
1514
1515 #if wxUSE_SPLINES
1516 // ----------------------------------- spline code ----------------------------------------
1517
1518 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1519                          double a3, double b3, double a4, double b4);
1520 void wx_clear_stack();
1521 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1522         double *y3, double *x4, double *y4);
1523 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1524           double x4, double y4);
1525 static bool wx_spline_add_point(double x, double y);
1526 static void wx_spline_draw_point_array(wxDC *dc);
1527
1528 wxList wx_spline_point_list;
1529
1530 #define                half(z1, z2)        ((z1+z2)/2.0)
1531 #define                THRESHOLD        5
1532
1533 /* iterative version */
1534
1535 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1536                  double b4)
1537 {
1538     register double  xmid, ymid;
1539     double           x1, y1, x2, y2, x3, y3, x4, y4;
1540
1541     wx_clear_stack();
1542     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1543
1544     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1545         xmid = (double)half(x2, x3);
1546         ymid = (double)half(y2, y3);
1547         if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1548             fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1549             wx_spline_add_point( x1, y1 );
1550             wx_spline_add_point( xmid, ymid );
1551         } else {
1552             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1553                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1554             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1555                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1556         }
1557     }
1558 }
1559
1560 /* utilities used by spline drawing routines */
1561
1562 typedef struct wx_spline_stack_struct {
1563     double           x1, y1, x2, y2, x3, y3, x4, y4;
1564 } Stack;
1565
1566 #define         SPLINE_STACK_DEPTH             20
1567 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
1568 static Stack   *wx_stack_top;
1569 static int      wx_stack_count;
1570
1571 void wx_clear_stack()
1572 {
1573     wx_stack_top = wx_spline_stack;
1574     wx_stack_count = 0;
1575 }
1576
1577 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1578 {
1579     wx_stack_top->x1 = x1;
1580     wx_stack_top->y1 = y1;
1581     wx_stack_top->x2 = x2;
1582     wx_stack_top->y2 = y2;
1583     wx_stack_top->x3 = x3;
1584     wx_stack_top->y3 = y3;
1585     wx_stack_top->x4 = x4;
1586     wx_stack_top->y4 = y4;
1587     wx_stack_top++;
1588     wx_stack_count++;
1589 }
1590
1591 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1592                   double *x3, double *y3, double *x4, double *y4)
1593 {
1594     if (wx_stack_count == 0)
1595         return (0);
1596     wx_stack_top--;
1597     wx_stack_count--;
1598     *x1 = wx_stack_top->x1;
1599     *y1 = wx_stack_top->y1;
1600     *x2 = wx_stack_top->x2;
1601     *y2 = wx_stack_top->y2;
1602     *x3 = wx_stack_top->x3;
1603     *y3 = wx_stack_top->y3;
1604     *x4 = wx_stack_top->x4;
1605     *y4 = wx_stack_top->y4;
1606     return (1);
1607 }
1608
1609 static bool wx_spline_add_point(double x, double y)
1610 {
1611   wxPoint *point = new wxPoint ;
1612   point->x = (int) x;
1613   point->y = (int) y;
1614   wx_spline_point_list.Append((wxObject*)point);
1615   return TRUE;
1616 }
1617
1618 static void wx_spline_draw_point_array(wxDC *dc)
1619 {
1620   dc->DrawLines(&wx_spline_point_list, 0, 0 );
1621   wxNode *node = wx_spline_point_list.First();
1622   while (node)
1623   {
1624     wxPoint *point = (wxPoint *)node->Data();
1625     delete point;
1626     delete node;
1627     node = wx_spline_point_list.First();
1628   }
1629 }
1630
1631 void wxWindowDC::DoDrawSpline( wxList *points )
1632 {
1633     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1634
1635     wxPoint *p;
1636     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1637     double           x1, y1, x2, y2;
1638
1639     wxNode *node = points->First();
1640     p = (wxPoint *)node->Data();
1641
1642     x1 = p->x;
1643     y1 = p->y;
1644
1645     node = node->Next();
1646     p = (wxPoint *)node->Data();
1647
1648     x2 = p->x;
1649     y2 = p->y;
1650     cx1 = (double)((x1 + x2) / 2);
1651     cy1 = (double)((y1 + y2) / 2);
1652     cx2 = (double)((cx1 + x2) / 2);
1653     cy2 = (double)((cy1 + y2) / 2);
1654
1655     wx_spline_add_point(x1, y1);
1656
1657     while ((node = node->Next()) != NULL)
1658     {
1659         p = (wxPoint *)node->Data();
1660         x1 = x2;
1661         y1 = y2;
1662         x2 = p->x;
1663         y2 = p->y;
1664         cx4 = (double)(x1 + x2) / 2;
1665         cy4 = (double)(y1 + y2) / 2;
1666         cx3 = (double)(x1 + cx4) / 2;
1667         cy3 = (double)(y1 + cy4) / 2;
1668
1669         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1670
1671         cx1 = cx4;
1672         cy1 = cy4;
1673         cx2 = (double)(cx1 + x2) / 2;
1674         cy2 = (double)(cy1 + y2) / 2;
1675     }
1676
1677     wx_spline_add_point( cx1, cy1 );
1678     wx_spline_add_point( x2, y2 );
1679
1680     wx_spline_draw_point_array( this );
1681 }
1682
1683 #endif // wxUSE_SPLINE
1684
1685 //-----------------------------------------------------------------------------
1686 // wxPaintDC
1687 //-----------------------------------------------------------------------------
1688
1689 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxWindowDC)
1690
1691 wxPaintDC::wxPaintDC()
1692   : wxWindowDC()
1693 {
1694 }
1695
1696 wxPaintDC::wxPaintDC( wxWindow *win )
1697   : wxWindowDC( win )
1698 {
1699 }
1700
1701 //-----------------------------------------------------------------------------
1702 // wxClientDC
1703 //-----------------------------------------------------------------------------
1704
1705 IMPLEMENT_DYNAMIC_CLASS(wxClientDC,wxWindowDC)
1706
1707 wxClientDC::wxClientDC()
1708   : wxWindowDC()
1709 {
1710 }
1711
1712 wxClientDC::wxClientDC( wxWindow *win )
1713   : wxWindowDC( win )
1714 {
1715 }
1716