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