src/gtk1/dcclient.cpp

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