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