src/gtk/dcclient.cpp

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