src/gtk1/dcclient.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk1/dcclient.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Chris Breeze
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __VMS
  14 #define XCopyPlane XCOPYPLANE
  15 #endif
  16
  17 #include "wx/dcclient.h"
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/log.h"
  21     #include "wx/dcmemory.h"
  22     #include "wx/math.h" // for floating-point functions
  23     #include "wx/image.h"
  24 #endif
  25
  26 #include "wx/module.h"
  27 #include "wx/fontutil.h"
  28
  29 #include "wx/gtk1/win_gtk.h"
  30
  31 #include <gdk/gdk.h>
  32 #include <gdk/gdkx.h>
  33 #include <gdk/gdkprivate.h>
  34 #include <gtk/gtk.h>
  35
  36 //-----------------------------------------------------------------------------
  37 // local defines
  38 //-----------------------------------------------------------------------------
  39
  40 #define USE_PAINT_REGION 1
  41
  42 //-----------------------------------------------------------------------------
  43 // local data
  44 //-----------------------------------------------------------------------------
  45
  46 #include "bdiag.xbm"
  47 #include "fdiag.xbm"
  48 #include "cdiag.xbm"
  49 #include "horiz.xbm"
  50 #include "verti.xbm"
  51 #include "cross.xbm"
  52 #define  num_hatches 6
  53
  54 #define IS_15_PIX_HATCH(s) ((s)==wxCROSSDIAG_HATCH || (s)==wxHORIZONTAL_HATCH || (s)==wxVERTICAL_HATCH)
  55 #define IS_16_PIX_HATCH(s) ((s)!=wxCROSSDIAG_HATCH && (s)!=wxHORIZONTAL_HATCH && (s)!=wxVERTICAL_HATCH)
  56
  57
  58 static GdkPixmap  *hatches[num_hatches];
  59 static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
  60
  61 extern GtkWidget *wxGetRootWindow();
  62
  63 //-----------------------------------------------------------------------------
  64 // constants
  65 //-----------------------------------------------------------------------------
  66
  67 const double RAD2DEG  = 180.0 / M_PI;
  68
  69 // ----------------------------------------------------------------------------
  70 // private functions
  71 // ----------------------------------------------------------------------------
  72
  73 static inline double dmax(double a, double b) { return a > b ? a : b; }
  74 static inline double dmin(double a, double b) { return a < b ? a : b; }
  75
  76 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  77
  78 //-----------------------------------------------------------------------------
  79 // temporary implementation of the missing GDK function
  80 //-----------------------------------------------------------------------------
  81
  82 #include "gdk/gdkprivate.h"
  83
  84 void gdk_wx_draw_bitmap(GdkDrawable  *drawable,
  85                         GdkGC        *gc,
  86                         GdkDrawable  *src,
  87                         gint         xsrc,
  88                         gint         ysrc,
  89                         gint         xdest,
  90                         gint         ydest,
  91                         gint         width,
  92                         gint         height)
  93 {
  94     wxCHECK_RET( drawable, _T("NULL drawable in gdk_wx_draw_bitmap") );
  95     wxCHECK_RET( src, _T("NULL src in gdk_wx_draw_bitmap") );
  96     wxCHECK_RET( gc, _T("NULL gc in gdk_wx_draw_bitmap") );
  97
  98     GdkWindowPrivate *drawable_private;
  99     GdkWindowPrivate *src_private;
 100     GdkGCPrivate *gc_private;
 101
 102     drawable_private = (GdkWindowPrivate*) drawable;
 103     src_private = (GdkWindowPrivate*) src;
 104     if (drawable_private->destroyed || src_private->destroyed)
 105         return;
 106
 107     gint src_width = src_private->width;
 108     gint src_height = src_private->height;
 109
 110     gc_private = (GdkGCPrivate*) gc;
 111
 112     if (width == -1) width = src_width;
 113     if (height == -1) height = src_height;
 114
 115     XCopyPlane( drawable_private->xdisplay,
 116                 src_private->xwindow,
 117                 drawable_private->xwindow,
 118                 gc_private->xgc,
 119                 xsrc, ysrc,
 120                 width, height,
 121                 xdest, ydest,
 122                 1 );
 123 }
 124
 125 //-----------------------------------------------------------------------------
 126 // Implement Pool of Graphic contexts. Creating them takes too much time.
 127 //-----------------------------------------------------------------------------
 128
 129 enum wxPoolGCType
 130 {
 131    wxGC_ERROR = 0,
 132    wxTEXT_MONO,
 133    wxBG_MONO,
 134    wxPEN_MONO,
 135    wxBRUSH_MONO,
 136    wxTEXT_COLOUR,
 137    wxBG_COLOUR,
 138    wxPEN_COLOUR,
 139    wxBRUSH_COLOUR,
 140    wxTEXT_SCREEN,
 141    wxBG_SCREEN,
 142    wxPEN_SCREEN,
 143    wxBRUSH_SCREEN
 144 };
 145
 146 struct wxGC
 147 {
 148     GdkGC        *m_gc;
 149     wxPoolGCType  m_type;
 150     bool          m_used;
 151 };
 152
 153 #define GC_POOL_ALLOC_SIZE 100
 154
 155 static int wxGCPoolSize = 0;
 156
 157 static wxGC *wxGCPool = NULL;
 158
 159 static void wxInitGCPool()
 160 {
 161     // This really could wait until the first call to
 162     // wxGetPoolGC, but we will make the first allocation
 163     // now when other initialization is being performed.
 164
 165     // Set initial pool size.
 166     wxGCPoolSize = GC_POOL_ALLOC_SIZE;
 167
 168     // Allocate initial pool.
 169     wxGCPool = (wxGC *)malloc(wxGCPoolSize * sizeof(wxGC));
 170     if (wxGCPool == NULL)
 171     {
 172         // If we cannot malloc, then fail with error
 173         // when debug is enabled.  If debug is not enabled,
 174         // the problem will eventually get caught
 175         // in wxGetPoolGC.
 176         wxFAIL_MSG( wxT("Cannot allocate GC pool") );
 177         return;
 178     }
 179
 180     // Zero initial pool.
 181     memset(wxGCPool, 0, wxGCPoolSize * sizeof(wxGC));
 182 }
 183
 184 static void wxCleanUpGCPool()
 185 {
 186     for (int i = 0; i < wxGCPoolSize; i++)
 187     {
 188         if (wxGCPool[i].m_gc)
 189             gdk_gc_unref( wxGCPool[i].m_gc );
 190     }
 191
 192     free(wxGCPool);
 193     wxGCPool = NULL;
 194     wxGCPoolSize = 0;
 195 }
 196
 197 static GdkGC* wxGetPoolGC( GdkWindow *window, wxPoolGCType type )
 198 {
 199     wxGC *pptr;
 200
 201     // Look for an available GC.
 202     for (int i = 0; i < wxGCPoolSize; i++)
 203     {
 204         if (!wxGCPool[i].m_gc)
 205         {
 206             wxGCPool[i].m_gc = gdk_gc_new( window );
 207             gdk_gc_set_exposures( wxGCPool[i].m_gc, FALSE );
 208             wxGCPool[i].m_type = type;
 209             wxGCPool[i].m_used = false;
 210         }
 211         if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
 212         {
 213             wxGCPool[i].m_used = true;
 214             return wxGCPool[i].m_gc;
 215         }
 216     }
 217
 218     // We did not find an available GC.
 219     // We need to grow the GC pool.
 220     pptr = (wxGC *)realloc(wxGCPool,
 221         (wxGCPoolSize + GC_POOL_ALLOC_SIZE)*sizeof(wxGC));
 222     if (pptr != NULL)
 223     {
 224         // Initialize newly allocated pool.
 225         wxGCPool = pptr;
 226         memset(&wxGCPool[wxGCPoolSize], 0,
 227             GC_POOL_ALLOC_SIZE*sizeof(wxGC));
 228
 229         // Initialize entry we will return.
 230         wxGCPool[wxGCPoolSize].m_gc = gdk_gc_new( window );
 231         gdk_gc_set_exposures( wxGCPool[wxGCPoolSize].m_gc, FALSE );
 232         wxGCPool[wxGCPoolSize].m_type = type;
 233         wxGCPool[wxGCPoolSize].m_used = true;
 234
 235         // Set new value of pool size.
 236         wxGCPoolSize += GC_POOL_ALLOC_SIZE;
 237
 238         // Return newly allocated entry.
 239         return wxGCPool[wxGCPoolSize-GC_POOL_ALLOC_SIZE].m_gc;
 240     }
 241
 242     // The realloc failed.  Fall through to error.
 243     wxFAIL_MSG( wxT("No GC available") );
 244
 245     return (GdkGC*) NULL;
 246 }
 247
 248 static void wxFreePoolGC( GdkGC *gc )
 249 {
 250     for (int i = 0; i < wxGCPoolSize; i++)
 251     {
 252         if (wxGCPool[i].m_gc == gc)
 253         {
 254             wxGCPool[i].m_used = false;
 255             return;
 256         }
 257     }
 258
 259     wxFAIL_MSG( wxT("Wrong GC") );
 260 }
 261
 262 //-----------------------------------------------------------------------------
 263 // wxWindowDC
 264 //-----------------------------------------------------------------------------
 265
 266 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 267
 268 wxWindowDC::wxWindowDC()
 269 {
 270     m_penGC = (GdkGC *) NULL;
 271     m_brushGC = (GdkGC *) NULL;
 272     m_textGC = (GdkGC *) NULL;
 273     m_bgGC = (GdkGC *) NULL;
 274     m_cmap = (GdkColormap *) NULL;
 275     m_isMemDC = false;
 276     m_isScreenDC = false;
 277     m_owner = (wxWindow *)NULL;
 278 }
 279
 280 wxWindowDC::wxWindowDC( wxWindow *window )
 281 {
 282     wxASSERT_MSG( window, wxT("DC needs a window") );
 283
 284     m_penGC = (GdkGC *) NULL;
 285     m_brushGC = (GdkGC *) NULL;
 286     m_textGC = (GdkGC *) NULL;
 287     m_bgGC = (GdkGC *) NULL;
 288     m_cmap = (GdkColormap *) NULL;
 289     m_owner = (wxWindow *)NULL;
 290     m_isMemDC = false;
 291     m_isScreenDC = false;
 292     m_font = window->GetFont();
 293
 294     GtkWidget *widget = window->m_wxwindow;
 295
 296     // Some controls don't have m_wxwindow - like wxStaticBox, but the user
 297     // code should still be able to create wxClientDCs for them, so we will
 298     // use the parent window here then.
 299     if ( !widget )
 300     {
 301         window = window->GetParent();
 302         widget = window->m_wxwindow;
 303     }
 304
 305     wxASSERT_MSG( widget, wxT("DC needs a widget") );
 306
 307     GtkPizza *pizza = GTK_PIZZA( widget );
 308     m_window = pizza->bin_window;
 309
 310     // Window not realized ?
 311     if (!m_window)
 312     {
 313          // Don't report problems as per MSW.
 314          m_ok = true;
 315
 316          return;
 317     }
 318
 319     m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
 320
 321     SetUpDC();
 322
 323     /* this must be done after SetUpDC, bacause SetUpDC calls the
 324        repective SetBrush, SetPen, SetBackground etc functions
 325        to set up the DC. SetBackground call m_owner->SetBackground
 326        and this might not be desired as the standard dc background
 327        is white whereas a window might assume gray to be the
 328        standard (as e.g. wxStatusBar) */
 329
 330     m_owner = window;
 331 }
 332
 333 wxWindowDC::~wxWindowDC()
 334 {
 335     Destroy();
 336 }
 337
 338 void wxWindowDC::SetUpDC()
 339 {
 340     m_ok = true;
 341
 342     wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
 343
 344     if (m_isScreenDC)
 345     {
 346         m_penGC = wxGetPoolGC( m_window, wxPEN_SCREEN );
 347         m_brushGC = wxGetPoolGC( m_window, wxBRUSH_SCREEN );
 348         m_textGC = wxGetPoolGC( m_window, wxTEXT_SCREEN );
 349         m_bgGC = wxGetPoolGC( m_window, wxBG_SCREEN );
 350     }
 351     else
 352     if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
 353     {
 354         m_penGC = wxGetPoolGC( m_window, wxPEN_MONO );
 355         m_brushGC = wxGetPoolGC( m_window, wxBRUSH_MONO );
 356         m_textGC = wxGetPoolGC( m_window, wxTEXT_MONO );
 357         m_bgGC = wxGetPoolGC( m_window, wxBG_MONO );
 358     }
 359     else
 360     {
 361         m_penGC = wxGetPoolGC( m_window, wxPEN_COLOUR );
 362         m_brushGC = wxGetPoolGC( m_window, wxBRUSH_COLOUR );
 363         m_textGC = wxGetPoolGC( m_window, wxTEXT_COLOUR );
 364         m_bgGC = wxGetPoolGC( m_window, wxBG_COLOUR );
 365     }
 366
 367     /* background colour */
 368     m_backgroundBrush = *wxWHITE_BRUSH;
 369     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
 370     GdkColor *bg_col = m_backgroundBrush.GetColour().GetColor();
 371
 372     /* m_textGC */
 373     m_textForegroundColour.CalcPixel( m_cmap );
 374     gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
 375
 376     m_textBackgroundColour.CalcPixel( m_cmap );
 377     gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
 378
 379     gdk_gc_set_fill( m_textGC, GDK_SOLID );
 380
 381     /* m_penGC */
 382     m_pen.GetColour().CalcPixel( m_cmap );
 383     gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
 384     gdk_gc_set_background( m_penGC, bg_col );
 385
 386     gdk_gc_set_line_attributes( m_penGC, 0, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_ROUND );
 387
 388     /* m_brushGC */
 389     m_brush.GetColour().CalcPixel( m_cmap );
 390     gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
 391     gdk_gc_set_background( m_brushGC, bg_col );
 392
 393     gdk_gc_set_fill( m_brushGC, GDK_SOLID );
 394
 395     /* m_bgGC */
 396     gdk_gc_set_background( m_bgGC, bg_col );
 397     gdk_gc_set_foreground( m_bgGC, bg_col );
 398
 399     gdk_gc_set_fill( m_bgGC, GDK_SOLID );
 400
 401     /* ROPs */
 402     gdk_gc_set_function( m_textGC, GDK_COPY );
 403     gdk_gc_set_function( m_brushGC, GDK_COPY );
 404     gdk_gc_set_function( m_penGC, GDK_COPY );
 405
 406     /* clipping */
 407     gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
 408     gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
 409     gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
 410     gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
 411
 412     if (!hatch_bitmap)
 413     {
 414         hatch_bitmap    = hatches;
 415         hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
 416         hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
 417         hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
 418         hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
 419         hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
 420         hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
 421     }
 422 }
 423
 424 void wxWindowDC::DoGetSize( int* width, int* height ) const
 425 {
 426     wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
 427
 428     m_owner->GetSize(width, height);
 429 }
 430
 431 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
 432                           const wxColour & col, int style);
 433
 434 bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
 435                              const wxColour& col, int style)
 436 {
 437     return wxDoFloodFill(this, x, y, col, style);
 438 }
 439
 440 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 441 {
 442     // Generic (and therefore rather inefficient) method.
 443     // Could be improved.
 444     wxMemoryDC memdc;
 445     wxBitmap bitmap(1, 1);
 446     memdc.SelectObject(bitmap);
 447     memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
 448     memdc.SelectObject(wxNullBitmap);
 449
 450     wxImage image = bitmap.ConvertToImage();
 451     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
 452     return true;
 453 }
 454
 455 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 456 {
 457     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 458
 459     if (m_pen.GetStyle() != wxTRANSPARENT)
 460     {
 461         if (m_window)
 462             gdk_draw_line( m_window, m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
 463
 464         CalcBoundingBox(x1, y1);
 465         CalcBoundingBox(x2, y2);
 466     }
 467 }
 468
 469 void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
 470 {
 471     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 472
 473     if (m_pen.GetStyle() != wxTRANSPARENT)
 474     {
 475         int w = 0;
 476         int h = 0;
 477         GetSize( &w, &h );
 478         wxCoord xx = XLOG2DEV(x);
 479         wxCoord yy = YLOG2DEV(y);
 480         if (m_window)
 481         {
 482             gdk_draw_line( m_window, m_penGC, 0, yy, XLOG2DEVREL(w), yy );
 483             gdk_draw_line( m_window, m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
 484         }
 485     }
 486 }
 487
 488 void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
 489                             wxCoord xc, wxCoord yc )
 490 {
 491     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 492
 493     wxCoord xx1 = XLOG2DEV(x1);
 494     wxCoord yy1 = YLOG2DEV(y1);
 495     wxCoord xx2 = XLOG2DEV(x2);
 496     wxCoord yy2 = YLOG2DEV(y2);
 497     wxCoord xxc = XLOG2DEV(xc);
 498     wxCoord yyc = YLOG2DEV(yc);
 499     double dx = xx1 - xxc;
 500     double dy = yy1 - yyc;
 501     double radius = sqrt((double)(dx*dx+dy*dy));
 502     wxCoord   r      = (wxCoord)radius;
 503     double radius1, radius2;
 504
 505     if (xx1 == xx2 && yy1 == yy2)
 506     {
 507         radius1 = 0.0;
 508         radius2 = 360.0;
 509     }
 510     else if ( wxIsNullDouble(radius) )
 511     {
 512         radius1 =
 513         radius2 = 0.0;
 514     }
 515     else
 516     {
 517         radius1 = (xx1 - xxc == 0) ?
 518             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 519             -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
 520         radius2 = (xx2 - xxc == 0) ?
 521             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 522             -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
 523     }
 524     wxCoord alpha1 = wxCoord(radius1 * 64.0);
 525     wxCoord alpha2 = wxCoord((radius2 - radius1) * 64.0);
 526     while (alpha2 <= 0) alpha2 += 360*64;
 527     while (alpha1 > 360*64) alpha1 -= 360*64;
 528
 529     if (m_window)
 530     {
 531         if (m_brush.GetStyle() != wxTRANSPARENT)
 532         {
 533             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 534             {
 535                 gdk_gc_set_ts_origin( m_textGC,
 536                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 537                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 538                 gdk_draw_arc( m_window, m_textGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 539                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 540             } else
 541             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 542             {
 543                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
 544                 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 545                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 546             } else
 547             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 548             {
 549                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
 550                 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 551                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 552             } else
 553             if (m_brush.GetStyle() == wxSTIPPLE)
 554             {
 555                 gdk_gc_set_ts_origin( m_brushGC,
 556                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 557                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 558                 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 559                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 560             }
 561             else
 562             {
 563                 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 564             }
 565         }
 566
 567         if (m_pen.GetStyle() != wxTRANSPARENT)
 568         {
 569             gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 570
 571             gdk_draw_line( m_window, m_penGC, xx1, yy1, xxc, yyc );
 572             gdk_draw_line( m_window, m_penGC, xxc, yyc, xx2, yy2 );
 573         }
 574     }
 575
 576     CalcBoundingBox (x1, y1);
 577     CalcBoundingBox (x2, y2);
 578 }
 579
 580 void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
 581 {
 582     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 583
 584     wxCoord xx = XLOG2DEV(x);
 585     wxCoord yy = YLOG2DEV(y);
 586     wxCoord ww = m_signX * XLOG2DEVREL(width);
 587     wxCoord hh = m_signY * YLOG2DEVREL(height);
 588
 589     // CMB: handle -ve width and/or height
 590     if (ww < 0) { ww = -ww; xx = xx - ww; }
 591     if (hh < 0) { hh = -hh; yy = yy - hh; }
 592
 593     if (m_window)
 594     {
 595         wxCoord start = wxCoord(sa * 64.0);
 596         wxCoord end = wxCoord((ea-sa) * 64.0);
 597
 598         if (m_brush.GetStyle() != wxTRANSPARENT)
 599         {
 600             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 601             {
 602                 gdk_gc_set_ts_origin( m_textGC,
 603                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 604                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 605                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, ww, hh, start, end );
 606                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 607             } else
 608             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 609             {
 610                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
 611                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
 612                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 613             } else
 614             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 615             {
 616                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
 617                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
 618                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 619             } else
 620             if (m_brush.GetStyle() == wxSTIPPLE)
 621             {
 622                 gdk_gc_set_ts_origin( m_brushGC,
 623                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 624                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 625                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
 626                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 627             }
 628             else
 629             {
 630                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
 631             }
 632         }
 633
 634         if (m_pen.GetStyle() != wxTRANSPARENT)
 635             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
 636     }
 637
 638     CalcBoundingBox (x, y);
 639     CalcBoundingBox (x + width, y + height);
 640 }
 641
 642 void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
 643 {
 644     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 645
 646     if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
 647         gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 648
 649     CalcBoundingBox (x, y);
 650 }
 651
 652 void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
 653 {
 654     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 655
 656     if (m_pen.GetStyle() == wxTRANSPARENT) return;
 657     if (n <= 0) return;
 658
 659     //Check, if scaling is necessary
 660     bool doScale(true);
 661     long val(10);
 662     if (!xoffset)
 663         if (!yoffset)
 664             if (XLOG2DEV(val)==val)
 665                 if (YLOG2DEV(val)==val)
 666                     doScale = false;
 667
 668     GdkPoint *gpts = NULL;
 669
 670     if (doScale){
 671         gpts = new GdkPoint[n];
 672     if (! gpts)
 673     {
 674         wxFAIL_MSG( wxT("Cannot allocate PolyLine") );
 675         return;
 676     }
 677
 678     for (int i = 0; i < n; i++)
 679     {
 680         wxCoord x1 = XLOG2DEV(points[i].x + xoffset);
 681         wxCoord y1 = YLOG2DEV(points[i].y + yoffset);
 682
 683         CalcBoundingBox( x1 + xoffset, y1 + yoffset );
 684
 685         gpts[i].x = x1;
 686         gpts[i].y = y1;
 687     }
 688     }
 689     else {
 690         for (int i = 0; i < n; i++) {
 691             CalcBoundingBox( points[i].x, points[i].y );
 692         }
 693
 694         //GdkPoint and wxPoint have the same memory allignment, so we can cast one into another
 695         gpts = reinterpret_cast<GdkPoint*>(points);
 696     }
 697
 698     if (m_window)
 699         gdk_draw_lines( m_window, m_penGC, gpts, n);
 700
 701     if (doScale)
 702     delete[] gpts;
 703 }
 704
 705 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int WXUNUSED(fillStyle) )
 706 {
 707     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 708
 709     if (n <= 0) return;
 710
 711     //Check, if scaling is necessary
 712     bool doScale(true);
 713     long val(10);
 714     if (!xoffset)
 715         if (!yoffset)
 716             if (XLOG2DEV(val)==val)
 717                 if (YLOG2DEV(val)==val){
 718                     doScale = false;
 719                 }
 720
 721     GdkPoint *gdkpoints = NULL;
 722
 723     if (doScale){
 724         gdkpoints = new GdkPoint[n+1]; //FIXME: Why the "+1"
 725
 726     int i;
 727     for (i = 0 ; i < n ; i++)
 728     {
 729         gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
 730         gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
 731
 732         CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
 733     }
 734     }
 735     else {
 736         int i(0);
 737         for (; i < n ; ++i) {
 738             CalcBoundingBox( points[i].x, points[i].y );
 739         }
 740         //GdkPoint and wxPoint have the same memory allignment, so we can cast one into another
 741         gdkpoints = reinterpret_cast<GdkPoint*> (points);
 742     }
 743
 744     if (m_window)
 745     {
 746         //I think wxSOLID is the most often used style (it is for me),
 747         //so I put it in front of the if ... ifelse's
 748         if (m_brush.GetStyle() == wxSOLID)
 749         {
 750             gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
 751         }else
 752         if (m_brush.GetStyle() != wxTRANSPARENT)
 753         {
 754             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 755             {
 756                 gdk_gc_set_ts_origin( m_textGC,
 757                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 758                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 759                 gdk_draw_polygon( m_window, m_textGC, TRUE, gdkpoints, n );
 760                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 761             } else
 762             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 763             {
 764                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
 765                 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
 766                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 767             } else
 768             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 769             {
 770                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
 771                 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
 772                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 773             } else
 774             if (m_brush.GetStyle() == wxSTIPPLE)
 775             {
 776                 gdk_gc_set_ts_origin( m_brushGC,
 777                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 778                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 779                 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
 780                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 781             }
 782             else
 783             {
 784                 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
 785             }
 786         }
 787
 788         if (m_pen.GetStyle() != wxTRANSPARENT)
 789         {
 790 /*
 791             for (i = 0 ; i < n ; i++)
 792             {
 793                 gdk_draw_line( m_window, m_penGC,
 794                                gdkpoints[i%n].x,
 795                                gdkpoints[i%n].y,
 796                                gdkpoints[(i+1)%n].x,
 797                                gdkpoints[(i+1)%n].y);
 798             }
 799 */
 800             gdk_draw_polygon( m_window, m_penGC, FALSE, gdkpoints, n );
 801
 802         }
 803     }
 804
 805     if (doScale)
 806     delete[] gdkpoints;
 807 }
 808
 809 void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 810 {
 811     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 812
 813     wxCoord xx = XLOG2DEV(x);
 814     wxCoord yy = YLOG2DEV(y);
 815     wxCoord ww = m_signX * XLOG2DEVREL(width);
 816     wxCoord hh = m_signY * YLOG2DEVREL(height);
 817
 818     // CMB: draw nothing if transformed w or h is 0
 819     if (ww == 0 || hh == 0) return;
 820
 821     // CMB: handle -ve width and/or height
 822     if (ww < 0) { ww = -ww; xx = xx - ww; }
 823     if (hh < 0) { hh = -hh; yy = yy - hh; }
 824
 825     if (m_window)
 826     {
 827         if (m_brush.GetStyle() != wxTRANSPARENT)
 828         {
 829             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 830             {
 831                 gdk_gc_set_ts_origin( m_textGC,
 832                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 833                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 834                 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx, yy, ww, hh );
 835                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 836             } else
 837             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 838             {
 839                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
 840                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
 841                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 842             } else
 843             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 844             {
 845                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
 846                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
 847                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 848             } else
 849             if (m_brush.GetStyle() == wxSTIPPLE)
 850             {
 851                 gdk_gc_set_ts_origin( m_brushGC,
 852                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 853                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 854                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
 855                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 856             }
 857             else
 858             {
 859                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
 860             }
 861         }
 862
 863         if (m_pen.GetStyle() != wxTRANSPARENT)
 864             gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
 865     }
 866
 867     CalcBoundingBox( x, y );
 868     CalcBoundingBox( x + width, y + height );
 869 }
 870
 871 void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
 872 {
 873     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 874
 875     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
 876
 877     wxCoord xx = XLOG2DEV(x);
 878     wxCoord yy = YLOG2DEV(y);
 879     wxCoord ww = m_signX * XLOG2DEVREL(width);
 880     wxCoord hh = m_signY * YLOG2DEVREL(height);
 881     wxCoord rr = XLOG2DEVREL((wxCoord)radius);
 882
 883     // CMB: handle -ve width and/or height
 884     if (ww < 0) { ww = -ww; xx = xx - ww; }
 885     if (hh < 0) { hh = -hh; yy = yy - hh; }
 886
 887     // CMB: if radius is zero use DrawRectangle() instead to avoid
 888     // X drawing errors with small radii
 889     if (rr == 0)
 890     {
 891         DrawRectangle( x, y, width, height );
 892         return;
 893     }
 894
 895     // CMB: draw nothing if transformed w or h is 0
 896     if (ww == 0 || hh == 0) return;
 897
 898     // CMB: adjust size if outline is drawn otherwise the result is
 899     // 1 pixel too wide and high
 900     if (m_pen.GetStyle() != wxTRANSPARENT)
 901     {
 902         ww--;
 903         hh--;
 904     }
 905
 906     if (m_window)
 907     {
 908         // CMB: ensure dd is not larger than rectangle otherwise we
 909         // get an hour glass shape
 910         wxCoord dd = 2 * rr;
 911         if (dd > ww) dd = ww;
 912         if (dd > hh) dd = hh;
 913         rr = dd / 2;
 914
 915         if (m_brush.GetStyle() != wxTRANSPARENT)
 916         {
 917             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 918             {
 919                 gdk_gc_set_ts_origin( m_textGC,
 920                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 921                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 922                 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 923                 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 924                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 925                 gdk_draw_arc( m_window, m_textGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 926                 gdk_draw_arc( m_window, m_textGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 927                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 928                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 929             } else
 930             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 931             {
 932                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
 933                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 934                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 935                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 936                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 937                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 938                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 939                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 940             } else
 941             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 942             {
 943                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
 944                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 945                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 946                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 947                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 948                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 949                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 950                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 951             } else
 952             if (m_brush.GetStyle() == wxSTIPPLE)
 953             {
 954                 gdk_gc_set_ts_origin( m_brushGC,
 955                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 956                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 957                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 958                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 959                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 960                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 961                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 962                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 963                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 964             }
 965             else
 966             {
 967                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 968                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 969                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 970                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 971                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 972                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 973             }
 974         }
 975
 976         if (m_pen.GetStyle() != wxTRANSPARENT)
 977         {
 978             gdk_draw_line( m_window, m_penGC, xx+rr+1, yy, xx+ww-rr, yy );
 979             gdk_draw_line( m_window, m_penGC, xx+rr+1, yy+hh, xx+ww-rr, yy+hh );
 980             gdk_draw_line( m_window, m_penGC, xx, yy+rr+1, xx, yy+hh-rr );
 981             gdk_draw_line( m_window, m_penGC, xx+ww, yy+rr+1, xx+ww, yy+hh-rr );
 982             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, dd, dd, 90*64, 90*64 );
 983             gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 984             gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 985             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 986         }
 987     }
 988
 989     // this ignores the radius
 990     CalcBoundingBox( x, y );
 991     CalcBoundingBox( x + width, y + height );
 992 }
 993
 994 void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 995 {
 996     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 997
 998     wxCoord xx = XLOG2DEV(x);
 999     wxCoord yy = YLOG2DEV(y);
1000     wxCoord ww = m_signX * XLOG2DEVREL(width);
1001     wxCoord hh = m_signY * YLOG2DEVREL(height);
1002
1003     // CMB: handle -ve width and/or height
1004     if (ww < 0) { ww = -ww; xx = xx - ww; }
1005     if (hh < 0) { hh = -hh; yy = yy - hh; }
1006
1007     if (m_window)
1008     {
1009         if (m_brush.GetStyle() != wxTRANSPARENT)
1010         {
1011             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1012             {
1013                 gdk_gc_set_ts_origin( m_textGC,
1014                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
1015                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
1016                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1017                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
1018             } else
1019             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
1020             {
1021                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
1022                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1023                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
1024             } else
1025             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
1026             {
1027                 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
1028                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1029                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
1030             } else
1031             if (m_brush.GetStyle() == wxSTIPPLE)
1032             {
1033                 gdk_gc_set_ts_origin( m_brushGC,
1034                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
1035                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
1036                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1037                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
1038             }
1039             else
1040             {
1041                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1042             }
1043         }
1044
1045         if (m_pen.GetStyle() != wxTRANSPARENT)
1046             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
1047     }
1048
1049     CalcBoundingBox( x, y );
1050     CalcBoundingBox( x + width, y + height );
1051 }
1052
1053 void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
1054 {
1055     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
1056     DoDrawBitmap( (const wxBitmap&)icon, x, y, true );
1057 }
1058
1059 void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
1060                                wxCoord x, wxCoord y,
1061                                bool useMask )
1062 {
1063     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1064
1065     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
1066
1067     bool is_mono = (bitmap.GetBitmap() != NULL);
1068
1069     // scale/translate size and position
1070     int xx = XLOG2DEV(x);
1071     int yy = YLOG2DEV(y);
1072
1073     int w = bitmap.GetWidth();
1074     int h = bitmap.GetHeight();
1075
1076     CalcBoundingBox( x, y );
1077     CalcBoundingBox( x + w, y + h );
1078
1079     if (!m_window) return;
1080
1081     int ww = XLOG2DEVREL(w);
1082     int hh = YLOG2DEVREL(h);
1083
1084     // compare to current clipping region
1085     if (!m_currentClippingRegion.IsNull())
1086     {
1087         wxRegion tmp( xx,yy,ww,hh );
1088         tmp.Intersect( m_currentClippingRegion );
1089         if (tmp.IsEmpty())
1090             return;
1091     }
1092
1093     // scale bitmap if required
1094     wxBitmap use_bitmap = bitmap;
1095     if ((w != ww) || (h != hh))
1096         use_bitmap = use_bitmap.Rescale( 0, 0, ww, hh, ww, hh );
1097
1098     // NB: We can't render pixbufs with GTK+ < 2.2, we need to use pixmaps code.
1099     //     Pixbufs-based bitmaps with alpha channel don't have a mask, so we
1100     //     have to call GetPixmap() here -- it converts the pixbuf into pixmap
1101     //     and also creates the mask as a side-effect:
1102     use_bitmap.GetPixmap();
1103
1104     // apply mask if any
1105     GdkBitmap *mask = (GdkBitmap *) NULL;
1106     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
1107
1108     GdkBitmap *new_mask = (GdkBitmap*) NULL;
1109
1110     if (useMask && mask)
1111     {
1112         if (!m_currentClippingRegion.IsNull())
1113         {
1114             GdkColor col;
1115             new_mask = gdk_pixmap_new( wxGetRootWindow()->window, ww, hh, 1 );
1116             GdkGC *gc = gdk_gc_new( new_mask );
1117             col.pixel = 0;
1118             gdk_gc_set_foreground( gc, &col );
1119             gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
1120             col.pixel = 0;
1121             gdk_gc_set_background( gc, &col );
1122             col.pixel = 1;
1123             gdk_gc_set_foreground( gc, &col );
1124             gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1125             gdk_gc_set_clip_origin( gc, -xx, -yy );
1126             gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1127             gdk_gc_set_stipple( gc, mask );
1128             gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
1129             gdk_gc_unref( gc );
1130         }
1131
1132         if (is_mono)
1133         {
1134             if (new_mask)
1135                 gdk_gc_set_clip_mask( m_textGC, new_mask );
1136             else
1137                 gdk_gc_set_clip_mask( m_textGC, mask );
1138             gdk_gc_set_clip_origin( m_textGC, xx, yy );
1139         }
1140         else
1141         {
1142             if (new_mask)
1143                 gdk_gc_set_clip_mask( m_penGC, new_mask );
1144             else
1145                 gdk_gc_set_clip_mask( m_penGC, mask );
1146             gdk_gc_set_clip_origin( m_penGC, xx, yy );
1147         }
1148     }
1149
1150     // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1151     // drawing a mono-bitmap (XBitmap) we use the current text GC
1152     if (is_mono)
1153     {
1154         gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), 0, 0, xx, yy, -1, -1 );
1155     }
1156     else
1157     {
1158         gdk_draw_pixmap(m_window, m_penGC,
1159                         use_bitmap.GetPixmap(),
1160                         0, 0, xx, yy, -1, -1);
1161     }
1162
1163     // remove mask again if any
1164     if (useMask && mask)
1165     {
1166         if (is_mono)
1167         {
1168             gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1169             gdk_gc_set_clip_origin( m_textGC, 0, 0 );
1170             if (!m_currentClippingRegion.IsNull())
1171                 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1172         }
1173         else
1174         {
1175             gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1176             gdk_gc_set_clip_origin( m_penGC, 0, 0 );
1177             if (!m_currentClippingRegion.IsNull())
1178                 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1179         }
1180     }
1181
1182     if (new_mask)
1183         gdk_bitmap_unref( new_mask );
1184 }
1185
1186 bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
1187                          wxCoord width, wxCoord height,
1188                          wxDC *source,
1189                          wxCoord xsrc, wxCoord ysrc,
1190                          int logical_func,
1191                          bool useMask,
1192                          wxCoord xsrcMask, wxCoord ysrcMask )
1193 {
1194     wxCHECK_MSG( Ok(), false, wxT("invalid window dc") );
1195
1196     wxCHECK_MSG( source, false, wxT("invalid source dc") );
1197
1198     if (!m_window) return false;
1199
1200     // transform the source DC coords to the device ones
1201     xsrc = source->XLOG2DEV(xsrc);
1202     ysrc = source->YLOG2DEV(ysrc);
1203
1204     wxClientDC *srcDC = (wxClientDC*)source;
1205     wxMemoryDC *memDC = (wxMemoryDC*)source;
1206
1207     bool use_bitmap_method = false;
1208     bool is_mono = false;
1209
1210     if (xsrcMask == -1 && ysrcMask == -1)
1211     {
1212         xsrcMask = xsrc;
1213         ysrcMask = ysrc;
1214     }
1215
1216     if (srcDC->m_isMemDC)
1217     {
1218         if (!memDC->m_selected.Ok()) return false;
1219
1220         is_mono = (memDC->m_selected.GetDepth() == 1);
1221
1222         // we use the "XCopyArea" way to copy a memory dc into
1223         // a different window if the memory dc BOTH
1224         // a) doesn't have any mask or its mask isn't used
1225         // b) it is clipped
1226         // c) is not 1-bit
1227
1228         if (useMask && (memDC->m_selected.GetMask()))
1229         {
1230             // we HAVE TO use the direct way for memory dcs
1231             // that have mask since the XCopyArea doesn't know
1232             // about masks
1233             use_bitmap_method = true;
1234         }
1235         else if (is_mono)
1236         {
1237             // we HAVE TO use the direct way for memory dcs
1238             // that are bitmaps because XCopyArea doesn't cope
1239             // with different bit depths
1240             use_bitmap_method = true;
1241         }
1242         else if ((xsrc == 0) && (ysrc == 0) &&
1243                  (width == memDC->m_selected.GetWidth()) &&
1244                  (height == memDC->m_selected.GetHeight()))
1245         {
1246             // we SHOULD use the direct way if all of the bitmap
1247             // in the memory dc is copied in which case XCopyArea
1248             // wouldn't be able able to boost performace by reducing
1249             // the area to be scaled
1250             use_bitmap_method = true;
1251         }
1252         else
1253         {
1254             use_bitmap_method = false;
1255         }
1256     }
1257
1258     CalcBoundingBox( xdest, ydest );
1259     CalcBoundingBox( xdest + width, ydest + height );
1260
1261     // scale/translate size and position
1262     wxCoord xx = XLOG2DEV(xdest);
1263     wxCoord yy = YLOG2DEV(ydest);
1264
1265     wxCoord ww = XLOG2DEVREL(width);
1266     wxCoord hh = YLOG2DEVREL(height);
1267
1268     // compare to current clipping region
1269     if (!m_currentClippingRegion.IsNull())
1270     {
1271         wxRegion tmp( xx,yy,ww,hh );
1272         tmp.Intersect( m_currentClippingRegion );
1273         if (tmp.IsEmpty())
1274             return true;
1275     }
1276
1277     int old_logical_func = m_logicalFunction;
1278     SetLogicalFunction( logical_func );
1279
1280     if (use_bitmap_method)
1281     {
1282         // scale/translate bitmap size
1283         wxCoord bm_width = memDC->m_selected.GetWidth();
1284         wxCoord bm_height = memDC->m_selected.GetHeight();
1285
1286         // Get clip coords for the bitmap. If we don't
1287         // use wxBitmap::Rescale(), which can clip the
1288         // bitmap, these are the same as the original
1289         // coordinates
1290         wxCoord cx = xx;
1291         wxCoord cy = yy;
1292         wxCoord cw = ww;
1293         wxCoord ch = hh;
1294
1295         // interpret userscale of src too
1296         double xsc,ysc;
1297         memDC->GetUserScale(&xsc,&ysc);
1298         bm_width = (int) (bm_width / xsc);
1299         bm_height = (int) (bm_height / ysc);
1300
1301         wxCoord bm_ww = XLOG2DEVREL( bm_width );
1302         wxCoord bm_hh = YLOG2DEVREL( bm_height );
1303
1304         // Scale bitmap if required
1305         wxBitmap use_bitmap;
1306         if ((memDC->m_selected.GetWidth()!= bm_ww) || ( memDC->m_selected.GetHeight()!= bm_hh))
1307         {
1308             // This indicates that the blitting code below will get
1309             // a clipped bitmap and therefore needs to move the origin
1310             // accordingly
1311             wxRegion tmp( xx,yy,ww,hh );
1312             tmp.Intersect( m_currentClippingRegion );
1313             tmp.GetBox(cx,cy,cw,ch);
1314
1315             // Scale and clipped bitmap
1316             use_bitmap = memDC->m_selected.Rescale(cx-xx,cy-yy,cw,ch,bm_ww,bm_hh);
1317         }
1318         else
1319         {
1320             // Don't scale bitmap
1321             use_bitmap = memDC->m_selected;
1322         }
1323
1324         // apply mask if any
1325         GdkBitmap *mask = (GdkBitmap *) NULL;
1326         if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
1327
1328         GdkBitmap *new_mask = (GdkBitmap*) NULL;
1329
1330         if (useMask && mask)
1331         {
1332             if (!m_currentClippingRegion.IsNull())
1333             {
1334                 GdkColor col;
1335                 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, bm_ww, bm_hh, 1 );
1336                 GdkGC *gc = gdk_gc_new( new_mask );
1337                 col.pixel = 0;
1338                 gdk_gc_set_foreground( gc, &col );
1339                 gdk_gc_set_ts_origin( gc, -xsrcMask, -ysrcMask);
1340                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1341                 col.pixel = 0;
1342                 gdk_gc_set_background( gc, &col );
1343                 col.pixel = 1;
1344                 gdk_gc_set_foreground( gc, &col );
1345                 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1346                 // was: gdk_gc_set_clip_origin( gc, -xx, -yy );
1347                 gdk_gc_set_clip_origin( gc, -cx, -cy );
1348                 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1349                 gdk_gc_set_stipple( gc, mask );
1350                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1351                 gdk_gc_unref( gc );
1352             }
1353
1354             if (is_mono)
1355             {
1356                 if (new_mask)
1357                 {
1358                     gdk_gc_set_clip_mask( m_textGC, new_mask );
1359                     gdk_gc_set_clip_origin( m_textGC, cx, cy );
1360                 }
1361                 else
1362                 {
1363                     gdk_gc_set_clip_mask( m_textGC, mask );
1364                     gdk_gc_set_clip_origin( m_textGC, cx-xsrcMask, cy-ysrcMask );
1365                 }
1366             }
1367             else
1368             {
1369                 if (new_mask)
1370                 {
1371                     gdk_gc_set_clip_mask( m_penGC, new_mask );
1372                     gdk_gc_set_clip_origin( m_penGC, cx, cy );
1373                 }
1374                 else
1375                 {
1376                     gdk_gc_set_clip_mask( m_penGC, mask );
1377                     gdk_gc_set_clip_origin( m_penGC, cx-xsrcMask, cy-ysrcMask );
1378                 }
1379             }
1380         }
1381
1382         // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1383         // drawing a mono-bitmap (XBitmap) we use the current text GC
1384
1385         if (is_mono)
1386         {
1387             // was: gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), xsrc, ysrc, xx, yy, ww, hh );
1388             gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), xsrc, ysrc, cx, cy, cw, ch );
1389         }
1390         else
1391         {
1392             // was: gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
1393             gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, cx, cy, cw, ch );
1394         }
1395
1396         // remove mask again if any
1397         if (useMask && mask)
1398         {
1399             if (is_mono)
1400             {
1401                 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1402                 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
1403                 if (!m_currentClippingRegion.IsNull())
1404                     gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1405             }
1406             else
1407             {
1408                 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1409                 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
1410                 if (!m_currentClippingRegion.IsNull())
1411                     gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1412             }
1413         }
1414
1415         if (new_mask)
1416             gdk_bitmap_unref( new_mask );
1417     }
1418     else // use_bitmap_method
1419     {
1420         if ((width != ww) || (height != hh))
1421         {
1422             // get clip coords
1423             wxRegion tmp( xx,yy,ww,hh );
1424             tmp.Intersect( m_currentClippingRegion );
1425             wxCoord cx,cy,cw,ch;
1426             tmp.GetBox(cx,cy,cw,ch);
1427
1428             // rescale bitmap
1429             wxBitmap bitmap = memDC->m_selected.Rescale( cx-xx, cy-yy, cw, ch, ww, hh );
1430
1431             // draw scaled bitmap
1432             // was: gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
1433             gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, cx, cy, -1, -1 );
1434         }
1435         else
1436         {
1437             // No scaling and not a memory dc with a mask either
1438
1439             // copy including child window contents
1440             gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1441             gdk_window_copy_area( m_window, m_penGC, xx, yy,
1442                                   srcDC->GetWindow(),
1443                                   xsrc, ysrc, width, height );
1444             gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1445         }
1446     }
1447
1448     SetLogicalFunction( old_logical_func );
1449
1450     return true;
1451 }
1452
1453 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
1454 {
1455     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1456
1457     if (!m_window) return;
1458
1459     if (text.empty()) return;
1460
1461     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1462
1463     wxCHECK_RET( font, wxT("invalid font") );
1464
1465     x = XLOG2DEV(x);
1466     y = YLOG2DEV(y);
1467
1468     wxCoord width = gdk_string_width( font, text.mbc_str() );
1469     wxCoord height = font->ascent + font->descent;
1470
1471     if ( m_backgroundMode == wxSOLID )
1472     {
1473         gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
1474         gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
1475         gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1476     }
1477     gdk_draw_string( m_window, font, m_textGC, x, y + font->ascent, text.mbc_str() );
1478
1479     /* CMB 17/7/98: simple underline: ignores scaling and underlying
1480        X font's XA_UNDERLINE_POSITION and XA_UNDERLINE_THICKNESS
1481        properties (see wxXt implementation) */
1482     if (m_font.GetUnderlined())
1483     {
1484         wxCoord ul_y = y + font->ascent;
1485         if (font->descent > 0) ul_y++;
1486         gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
1487     }
1488
1489     width = wxCoord(width / m_scaleX);
1490     height = wxCoord(height / m_scaleY);
1491     CalcBoundingBox (x + width, y + height);
1492     CalcBoundingBox (x, y);
1493 }
1494
1495
1496 // TODO: There is an example of rotating text with GTK2 that would probably be
1497 // a better approach here:
1498 //           http://www.daa.com.au/pipermail/pygtk/2003-April/005052.html
1499
1500 void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1501 {
1502     if ( wxIsNullDouble(angle) )
1503     {
1504         DrawText(text, x, y);
1505         return;
1506     }
1507
1508     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1509
1510     if (!m_window) return;
1511
1512     wxCoord w;
1513     wxCoord h;
1514
1515     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1516
1517     wxCHECK_RET( font, wxT("invalid font") );
1518
1519     // the size of the text
1520     w = gdk_string_width( font, text.mbc_str() );
1521     h = font->ascent + font->descent;
1522
1523     // draw the string normally
1524     wxBitmap src(w, h);
1525     wxMemoryDC dc;
1526     dc.SelectObject(src);
1527     dc.SetFont(GetFont());
1528     dc.SetBackground(*wxBLACK_BRUSH);
1529     dc.SetBrush(*wxBLACK_BRUSH);
1530     dc.Clear();
1531     dc.SetTextForeground( *wxWHITE );
1532     dc.DrawText(text, 0, 0);
1533     dc.SelectObject(wxNullBitmap);
1534
1535     // Calculate the size of the rotated bounding box.
1536     double rad = DegToRad(angle);
1537     double dx = cos(rad),
1538            dy = sin(rad);
1539
1540     // the rectngle vertices are counted clockwise with the first one being at
1541     // (0, 0) (or, rather, at (x, y))
1542     double x2 = w*dx,
1543            y2 = -w*dy;      // y axis points to the bottom, hence minus
1544     double x4 = h*dy,
1545            y4 = h*dx;
1546     double x3 = x4 + x2,
1547            y3 = y4 + y2;
1548
1549     // calc max and min
1550     wxCoord maxX = (wxCoord)(dmax(x2, dmax(x3, x4)) + 0.5),
1551             maxY = (wxCoord)(dmax(y2, dmax(y3, y4)) + 0.5),
1552             minX = (wxCoord)(dmin(x2, dmin(x3, x4)) - 0.5),
1553             minY = (wxCoord)(dmin(y2, dmin(y3, y4)) - 0.5);
1554
1555
1556     wxImage image = src.ConvertToImage();
1557
1558     image.ConvertColourToAlpha( m_textForegroundColour.Red(),
1559                                 m_textForegroundColour.Green(),
1560                                 m_textForegroundColour.Blue() );
1561     image = image.Rotate( rad, wxPoint(0,0) );
1562
1563     int i_angle = (int) angle;
1564     i_angle = i_angle % 360;
1565     if (i_angle < 0)
1566         i_angle += 360;
1567     int xoffset = 0;
1568     if ((i_angle >= 90.0) && (i_angle < 270.0))
1569         xoffset = image.GetWidth();
1570     int yoffset = 0;
1571     if ((i_angle >= 0.0) && (i_angle < 180.0))
1572         yoffset = image.GetHeight();
1573
1574     if ((i_angle >= 0) && (i_angle < 90))
1575         yoffset -= (int)( cos(rad)*h );
1576     if ((i_angle >= 90) && (i_angle < 180))
1577         xoffset -= (int)( sin(rad)*h );
1578     if ((i_angle >= 180) && (i_angle < 270))
1579         yoffset -= (int)( cos(rad)*h );
1580     if ((i_angle >= 270) && (i_angle < 360))
1581         xoffset -= (int)( sin(rad)*h );
1582
1583     int i_x = x - xoffset;
1584     int i_y = y - yoffset;
1585
1586     src = image;
1587     DoDrawBitmap( src, i_x, i_y, true );
1588
1589
1590     // it would be better to draw with non underlined font and draw the line
1591     // manually here (it would be more straight...)
1592 #if 0
1593     if ( m_font.GetUnderlined() )
1594     {
1595         gdk_draw_line( m_window, m_textGC,
1596                        XLOG2DEV(x + x4), YLOG2DEV(y + y4 + font->descent),
1597                        XLOG2DEV(x + x3), YLOG2DEV(y + y3 + font->descent));
1598     }
1599 #endif // 0
1600
1601     // update the bounding box
1602     CalcBoundingBox(x + minX, y + minY);
1603     CalcBoundingBox(x + maxX, y + maxY);
1604 }
1605
1606 void wxWindowDC::DoGetTextExtent(const wxString &string,
1607                                  wxCoord *width, wxCoord *height,
1608                                  wxCoord *descent, wxCoord *externalLeading,
1609                                  wxFont *theFont) const
1610 {
1611     if ( width )
1612         *width = 0;
1613     if ( height )
1614         *height = 0;
1615     if ( descent )
1616         *descent = 0;
1617     if ( externalLeading )
1618         *externalLeading = 0;
1619
1620     if (string.empty())
1621     {
1622         return;
1623     }
1624
1625     wxFont fontToUse = m_font;
1626     if (theFont)
1627         fontToUse = *theFont;
1628
1629     GdkFont *font = fontToUse.GetInternalFont( m_scaleY );
1630     if ( !font )
1631         return;
1632
1633     if (width)
1634         *width = wxCoord(gdk_string_width( font, string.mbc_str() ) / m_scaleX);
1635     if (height)
1636         *height = wxCoord((font->ascent + font->descent) / m_scaleY);
1637     if (descent)
1638         *descent = wxCoord(font->descent / m_scaleY);
1639 }
1640
1641 wxCoord wxWindowDC::GetCharWidth() const
1642 {
1643     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1644     wxCHECK_MSG( font, -1, wxT("invalid font") );
1645
1646     return wxCoord(gdk_string_width( font, "H" ) / m_scaleX);
1647 }
1648
1649 wxCoord wxWindowDC::GetCharHeight() const
1650 {
1651     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1652     wxCHECK_MSG( font, -1, wxT("invalid font") );
1653
1654     return wxCoord((font->ascent + font->descent) / m_scaleY);
1655 }
1656
1657 void wxWindowDC::Clear()
1658 {
1659     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1660
1661     if (!m_window) return;
1662
1663     // VZ: the code below results in infinite recursion and crashes when
1664     //     dc.Clear() is done from OnPaint() so I disable it for now.
1665     //     I don't know what the correct fix is but Clear() surely should not
1666     //     reenter OnPaint()!
1667 #if 0
1668     /* - we either are a memory dc or have a window as the
1669        owner. anything else shouldn't happen.
1670        - we don't use gdk_window_clear() as we don't set
1671        the window's background colour anymore. it is too
1672        much pain to keep the DC's and the window's back-
1673        ground colour in synch. */
1674
1675     if (m_owner)
1676     {
1677         m_owner->Clear();
1678         return;
1679     }
1680
1681     if (m_isMemDC)
1682     {
1683         int width,height;
1684         GetSize( &width, &height );
1685         gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
1686         return;
1687     }
1688 #else // 1
1689     int width,height;
1690     GetSize( &width, &height );
1691     gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
1692 #endif // 0/1
1693 }
1694
1695 void wxWindowDC::SetFont( const wxFont &font )
1696 {
1697     m_font = font;
1698 }
1699
1700 void wxWindowDC::SetPen( const wxPen &pen )
1701 {
1702     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1703
1704     if (m_pen == pen) return;
1705
1706     m_pen = pen;
1707
1708     if (!m_pen.Ok()) return;
1709
1710     if (!m_window) return;
1711
1712     gint width = m_pen.GetWidth();
1713     if (width <= 0)
1714     {
1715         // CMB: if width is non-zero scale it with the dc
1716         width = 1;
1717     }
1718     else
1719     {
1720         // X doesn't allow different width in x and y and so we take
1721         // the average
1722         double w = 0.5 +
1723                    ( fabs((double) XLOG2DEVREL(width)) +
1724                      fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1725         width = (int)w;
1726         if ( !width )
1727         {
1728             // width can't be 0 or an internal GTK error occurs inside
1729             // gdk_gc_set_dashes() below
1730             width = 1;
1731         }
1732     }
1733
1734     static const wxGTKDash dotted[] = {1, 1};
1735     static const wxGTKDash short_dashed[] = {2, 2};
1736     static const wxGTKDash wxCoord_dashed[] = {2, 4};
1737     static const wxGTKDash dotted_dashed[] = {3, 3, 1, 3};
1738
1739     // We express dash pattern in pen width unit, so we are
1740     // independent of zoom factor and so on...
1741     int req_nb_dash;
1742     const wxGTKDash *req_dash;
1743
1744     GdkLineStyle lineStyle = GDK_LINE_SOLID;
1745     switch (m_pen.GetStyle())
1746     {
1747         case wxUSER_DASH:
1748         {
1749             lineStyle = GDK_LINE_ON_OFF_DASH;
1750             req_nb_dash = m_pen.GetDashCount();
1751             req_dash = (wxGTKDash*)m_pen.GetDash();
1752             break;
1753         }
1754         case wxDOT:
1755         {
1756             lineStyle = GDK_LINE_ON_OFF_DASH;
1757             req_nb_dash = 2;
1758             req_dash = dotted;
1759             break;
1760         }
1761         case wxLONG_DASH:
1762         {
1763             lineStyle = GDK_LINE_ON_OFF_DASH;
1764             req_nb_dash = 2;
1765             req_dash = wxCoord_dashed;
1766             break;
1767         }
1768         case wxSHORT_DASH:
1769         {
1770             lineStyle = GDK_LINE_ON_OFF_DASH;
1771             req_nb_dash = 2;
1772             req_dash = short_dashed;
1773             break;
1774         }
1775         case wxDOT_DASH:
1776         {
1777 //            lineStyle = GDK_LINE_DOUBLE_DASH;
1778             lineStyle = GDK_LINE_ON_OFF_DASH;
1779             req_nb_dash = 4;
1780             req_dash = dotted_dashed;
1781             break;
1782         }
1783
1784         case wxTRANSPARENT:
1785         case wxSTIPPLE_MASK_OPAQUE:
1786         case wxSTIPPLE:
1787         case wxSOLID:
1788         default:
1789         {
1790             lineStyle = GDK_LINE_SOLID;
1791             req_dash = (wxGTKDash*)NULL;
1792             req_nb_dash = 0;
1793             break;
1794         }
1795     }
1796
1797     if (req_dash && req_nb_dash)
1798     {
1799         wxGTKDash *real_req_dash = new wxGTKDash[req_nb_dash];
1800         if (real_req_dash)
1801         {
1802             for (int i = 0; i < req_nb_dash; i++)
1803                 real_req_dash[i] = req_dash[i] * width;
1804             gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
1805             delete[] real_req_dash;
1806         }
1807         else
1808         {
1809             // No Memory. We use non-scaled dash pattern...
1810             gdk_gc_set_dashes( m_penGC, 0, (wxGTKDash*)req_dash, req_nb_dash );
1811         }
1812     }
1813
1814     GdkCapStyle capStyle = GDK_CAP_ROUND;
1815     switch (m_pen.GetCap())
1816     {
1817         case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
1818         case wxCAP_BUTT:       { capStyle = GDK_CAP_BUTT;       break; }
1819         case wxCAP_ROUND:
1820         default:
1821         {
1822             if (width <= 1)
1823             {
1824                 width = 0;
1825                 capStyle = GDK_CAP_NOT_LAST;
1826             }
1827             else
1828             {
1829                 capStyle = GDK_CAP_ROUND;
1830             }
1831             break;
1832         }
1833     }
1834
1835     GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
1836     switch (m_pen.GetJoin())
1837     {
1838         case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
1839         case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
1840         case wxJOIN_ROUND:
1841         default:           { joinStyle = GDK_JOIN_ROUND; break; }
1842     }
1843
1844     gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
1845
1846     m_pen.GetColour().CalcPixel( m_cmap );
1847     gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
1848 }
1849
1850 void wxWindowDC::SetBrush( const wxBrush &brush )
1851 {
1852     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1853
1854     if (m_brush == brush) return;
1855
1856     m_brush = brush;
1857
1858     if (!m_brush.Ok()) return;
1859
1860     if (!m_window) return;
1861
1862     m_brush.GetColour().CalcPixel( m_cmap );
1863     gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
1864
1865     gdk_gc_set_fill( m_brushGC, GDK_SOLID );
1866
1867     if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1868     {
1869         if (m_brush.GetStipple()->GetPixmap())
1870         {
1871             gdk_gc_set_fill( m_brushGC, GDK_TILED );
1872             gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
1873         }
1874         else
1875         {
1876             gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1877             gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetBitmap() );
1878         }
1879     }
1880
1881     if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1882     {
1883         gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);
1884         gdk_gc_set_stipple( m_textGC, m_brush.GetStipple()->GetMask()->GetBitmap() );
1885     }
1886
1887     if (m_brush.IsHatch())
1888     {
1889         gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1890         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1891         gdk_gc_set_stipple( m_brushGC, hatches[num] );
1892     }
1893 }
1894
1895 void wxWindowDC::SetBackground( const wxBrush &brush )
1896 {
1897    /* CMB 21/7/98: Added SetBackground. Sets background brush
1898     * for Clear() and bg colour for shapes filled with cross-hatch brush */
1899
1900     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1901
1902     if (m_backgroundBrush == brush) return;
1903
1904     m_backgroundBrush = brush;
1905
1906     if (!m_backgroundBrush.Ok()) return;
1907
1908     if (!m_window) return;
1909
1910     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1911     gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
1912     gdk_gc_set_background( m_penGC, m_backgroundBrush.GetColour().GetColor() );
1913     gdk_gc_set_background( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1914     gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1915
1916     gdk_gc_set_fill( m_bgGC, GDK_SOLID );
1917
1918     if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1919     {
1920         if (m_backgroundBrush.GetStipple()->GetPixmap())
1921         {
1922             gdk_gc_set_fill( m_bgGC, GDK_TILED );
1923             gdk_gc_set_tile( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
1924         }
1925         else
1926         {
1927             gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1928             gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetBitmap() );
1929         }
1930     }
1931
1932     if (m_backgroundBrush.IsHatch())
1933     {
1934         gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1935         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1936         gdk_gc_set_stipple( m_bgGC, hatches[num] );
1937     }
1938 }
1939
1940 void wxWindowDC::SetLogicalFunction( int function )
1941 {
1942     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1943
1944     if (m_logicalFunction == function)
1945         return;
1946
1947     // VZ: shouldn't this be a CHECK?
1948     if (!m_window)
1949         return;
1950
1951     GdkFunction mode;
1952     switch (function)
1953     {
1954         case wxXOR:          mode = GDK_XOR;           break;
1955         case wxINVERT:       mode = GDK_INVERT;        break;
1956         case wxOR_REVERSE:   mode = GDK_OR_REVERSE;    break;
1957         case wxAND_REVERSE:  mode = GDK_AND_REVERSE;   break;
1958         case wxCLEAR:        mode = GDK_CLEAR;         break;
1959         case wxSET:          mode = GDK_SET;           break;
1960         case wxOR_INVERT:    mode = GDK_OR_INVERT;     break;
1961         case wxAND:          mode = GDK_AND;           break;
1962         case wxOR:           mode = GDK_OR;            break;
1963         case wxEQUIV:        mode = GDK_EQUIV;         break;
1964         case wxNAND:         mode = GDK_NAND;          break;
1965         case wxAND_INVERT:   mode = GDK_AND_INVERT;    break;
1966         case wxCOPY:         mode = GDK_COPY;          break;
1967         case wxNO_OP:        mode = GDK_NOOP;          break;
1968         case wxSRC_INVERT:   mode = GDK_COPY_INVERT;   break;
1969
1970         // unsupported by GTK
1971         case wxNOR:          mode = GDK_COPY;          break;
1972         default:
1973            wxFAIL_MSG( wxT("unsupported logical function") );
1974            mode = GDK_COPY;
1975     }
1976
1977     m_logicalFunction = function;
1978
1979     gdk_gc_set_function( m_penGC, mode );
1980     gdk_gc_set_function( m_brushGC, mode );
1981
1982     // to stay compatible with wxMSW, we don't apply ROPs to the text
1983     // operations (i.e. DrawText/DrawRotatedText).
1984     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
1985     gdk_gc_set_function( m_textGC, mode );
1986 }
1987
1988 void wxWindowDC::SetTextForeground( const wxColour &col )
1989 {
1990     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1991
1992     // don't set m_textForegroundColour to an invalid colour as we'd crash
1993     // later then (we use m_textForegroundColour.GetColor() without checking
1994     // in a few places)
1995     if ( !col.Ok() || (m_textForegroundColour == col) )
1996         return;
1997
1998     m_textForegroundColour = col;
1999
2000     if ( m_window )
2001     {
2002         m_textForegroundColour.CalcPixel( m_cmap );
2003         gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
2004     }
2005 }
2006
2007 void wxWindowDC::SetTextBackground( const wxColour &col )
2008 {
2009     wxCHECK_RET( Ok(), wxT("invalid window dc") );
2010
2011     // same as above
2012     if ( !col.Ok() || (m_textBackgroundColour == col) )
2013         return;
2014
2015     m_textBackgroundColour = col;
2016
2017     if ( m_window )
2018     {
2019         m_textBackgroundColour.CalcPixel( m_cmap );
2020         gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
2021     }
2022 }
2023
2024 void wxWindowDC::SetBackgroundMode( int mode )
2025 {
2026     wxCHECK_RET( Ok(), wxT("invalid window dc") );
2027
2028     m_backgroundMode = mode;
2029
2030     if (!m_window) return;
2031
2032     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
2033     // transparent/solid background mode
2034
2035     if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
2036     {
2037         gdk_gc_set_fill( m_brushGC,
2038           (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
2039     }
2040 }
2041
2042 void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
2043 {
2044     wxFAIL_MSG( wxT("wxWindowDC::SetPalette not implemented") );
2045 }
2046
2047 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
2048 {
2049     wxCHECK_RET( Ok(), wxT("invalid window dc") );
2050
2051     if (!m_window) return;
2052
2053     wxRect rect;
2054     rect.x = XLOG2DEV(x);
2055     rect.y = YLOG2DEV(y);
2056     rect.width = XLOG2DEVREL(width);
2057     rect.height = YLOG2DEVREL(height);
2058
2059     if (!m_currentClippingRegion.IsNull())
2060         m_currentClippingRegion.Intersect( rect );
2061     else
2062         m_currentClippingRegion.Union( rect );
2063
2064 #if USE_PAINT_REGION
2065     if (!m_paintClippingRegion.IsNull())
2066         m_currentClippingRegion.Intersect( m_paintClippingRegion );
2067 #endif
2068
2069     wxCoord xx, yy, ww, hh;
2070     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2071     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
2072
2073     gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
2074     gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
2075     gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
2076     gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
2077 }
2078
2079 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion &region  )
2080 {
2081     wxCHECK_RET( Ok(), wxT("invalid window dc") );
2082
2083     if (region.Empty())
2084     {
2085         DestroyClippingRegion();
2086         return;
2087     }
2088
2089     if (!m_window) return;
2090
2091     if (!m_currentClippingRegion.IsNull())
2092         m_currentClippingRegion.Intersect( region );
2093     else
2094         m_currentClippingRegion.Union( region );
2095
2096 #if USE_PAINT_REGION
2097     if (!m_paintClippingRegion.IsNull())
2098         m_currentClippingRegion.Intersect( m_paintClippingRegion );
2099 #endif
2100
2101     wxCoord xx, yy, ww, hh;
2102     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2103     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
2104
2105     gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
2106     gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
2107     gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
2108     gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
2109 }
2110
2111 void wxWindowDC::DestroyClippingRegion()
2112 {
2113     wxCHECK_RET( Ok(), wxT("invalid window dc") );
2114
2115     wxDC::DestroyClippingRegion();
2116
2117     m_currentClippingRegion.Clear();
2118
2119 #if USE_PAINT_REGION
2120     if (!m_paintClippingRegion.IsEmpty())
2121         m_currentClippingRegion.Union( m_paintClippingRegion );
2122 #endif
2123
2124     if (!m_window) return;
2125
2126     if (m_currentClippingRegion.IsEmpty())
2127     {
2128         gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
2129         gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
2130         gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
2131         gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
2132     }
2133     else
2134     {
2135         gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
2136         gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
2137         gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
2138         gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
2139     }
2140 }
2141
2142 void wxWindowDC::Destroy()
2143 {
2144     if (m_penGC) wxFreePoolGC( m_penGC );
2145     m_penGC = (GdkGC*) NULL;
2146     if (m_brushGC) wxFreePoolGC( m_brushGC );
2147     m_brushGC = (GdkGC*) NULL;
2148     if (m_textGC) wxFreePoolGC( m_textGC );
2149     m_textGC = (GdkGC*) NULL;
2150     if (m_bgGC) wxFreePoolGC( m_bgGC );
2151     m_bgGC = (GdkGC*) NULL;
2152 }
2153
2154 void wxWindowDC::ComputeScaleAndOrigin()
2155 {
2156     const wxRealPoint origScale(m_scaleX, m_scaleY);
2157
2158     wxDC::ComputeScaleAndOrigin();
2159
2160     // if scale has changed call SetPen to recalulate the line width
2161     if ( wxRealPoint(m_scaleX, m_scaleY) != origScale && m_pen.Ok() )
2162     {
2163         // this is a bit artificial, but we need to force wxDC to think the pen
2164         // has changed
2165         wxPen pen = m_pen;
2166         m_pen = wxNullPen;
2167         SetPen( pen );
2168     }
2169 }
2170
2171 // Resolution in pixels per logical inch
2172 wxSize wxWindowDC::GetPPI() const
2173 {
2174     return wxSize( (int) (m_mm_to_pix_x * 25.4 + 0.5), (int) (m_mm_to_pix_y * 25.4 + 0.5));
2175 }
2176
2177 int wxWindowDC::GetDepth() const
2178 {
2179     wxFAIL_MSG(wxT("not implemented"));
2180
2181     return -1;
2182 }
2183
2184
2185 //-----------------------------------------------------------------------------
2186 // wxPaintDC
2187 //-----------------------------------------------------------------------------
2188
2189 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
2190
2191 // Limit the paint region to the window size. Sometimes
2192 // the paint region is too big, and this risks X11 errors
2193 static void wxLimitRegionToSize(wxRegion& region, const wxSize& sz)
2194 {
2195     wxRect originalRect = region.GetBox();
2196     wxRect rect(originalRect);
2197     if (rect.width + rect.x > sz.x)
2198         rect.width = sz.x - rect.x;
2199     if (rect.height + rect.y > sz.y)
2200         rect.height = sz.y - rect.y;
2201     if (rect != originalRect)
2202     {
2203         region = wxRegion(rect);
2204         wxLogTrace(wxT("painting"), wxT("Limiting region from %d, %d, %d, %d to %d, %d, %d, %d\n"),
2205                    originalRect.x, originalRect.y, originalRect.width, originalRect.height,
2206                    rect.x, rect.y, rect.width, rect.height);
2207     }
2208 }
2209
2210 wxPaintDC::wxPaintDC( wxWindow *win )
2211          : wxClientDC( win )
2212 {
2213 #if USE_PAINT_REGION
2214     if (!win->m_clipPaintRegion)
2215         return;
2216
2217     wxSize sz = win->GetSize();
2218     m_paintClippingRegion = win->GetUpdateRegion();
2219     wxLimitRegionToSize(m_paintClippingRegion, sz);
2220
2221     GdkRegion *region = m_paintClippingRegion.GetRegion();
2222     if ( region )
2223     {
2224         m_currentClippingRegion.Union( m_paintClippingRegion );
2225         wxLimitRegionToSize(m_currentClippingRegion, sz);
2226
2227         if (sz.x <= 0 || sz.y <= 0)
2228             return ;
2229
2230         gdk_gc_set_clip_region( m_penGC, region );
2231         gdk_gc_set_clip_region( m_brushGC, region );
2232         gdk_gc_set_clip_region( m_textGC, region );
2233         gdk_gc_set_clip_region( m_bgGC, region );
2234     }
2235 #endif // USE_PAINT_REGION
2236 }
2237
2238 //-----------------------------------------------------------------------------
2239 // wxClientDC
2240 //-----------------------------------------------------------------------------
2241
2242 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
2243
2244 wxClientDC::wxClientDC( wxWindow *win )
2245           : wxWindowDC( win )
2246 {
2247     wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
2248
2249 #ifdef __WXUNIVERSAL__
2250     wxPoint ptOrigin = win->GetClientAreaOrigin();
2251     SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
2252     wxSize size = win->GetClientSize();
2253     SetClippingRegion(wxPoint(0, 0), size);
2254 #endif // __WXUNIVERSAL__
2255 }
2256
2257 void wxClientDC::DoGetSize(int *width, int *height) const
2258 {
2259     wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
2260
2261     m_owner->GetClientSize( width, height );
2262 }
2263
2264 // ----------------------------------------------------------------------------
2265 // wxDCModule
2266 // ----------------------------------------------------------------------------
2267
2268 class wxDCModule : public wxModule
2269 {
2270 public:
2271     bool OnInit();
2272     void OnExit();
2273
2274 private:
2275     DECLARE_DYNAMIC_CLASS(wxDCModule)
2276 };
2277
2278 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2279
2280 bool wxDCModule::OnInit()
2281 {
2282     wxInitGCPool();
2283     return true;
2284 }
2285
2286 void wxDCModule::OnExit()
2287 {
2288     wxCleanUpGCPool();
2289 }