src/gtk/dcclient.cpp

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