src/gtk1/dcclient.cpp

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