src/gtk/dcclient.cpp

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