src/x11/dcclient.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        x11/dcclient.cpp
   3 // Purpose:     wxClientDC class
   4 // Author:      Julian Smart, Robert Roebling
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart, Robert Roebling
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "dcclient.h"
  14 #endif
  15
  16 #include "wx/dcclient.h"
  17 #include "wx/dcmemory.h"
  18 #include "wx/window.h"
  19 #include "wx/app.h"
  20 #include "wx/image.h"
  21
  22 #include "wx/x11/private.h"
  23
  24 #include <math.h>
  25
  26 //-----------------------------------------------------------------------------
  27 // local defines
  28 //-----------------------------------------------------------------------------
  29
  30 #define USE_PAINT_REGION 1
  31
  32 //-----------------------------------------------------------------------------
  33 // local data
  34 //-----------------------------------------------------------------------------
  35
  36 #include "bdiag.xbm"
  37 #include "fdiag.xbm"
  38 #include "cdiag.xbm"
  39 #include "horiz.xbm"
  40 #include "verti.xbm"
  41 #include "cross.xbm"
  42 #define  num_hatches 6
  43
  44 #define IS_15_PIX_HATCH(s) ((s)==wxCROSSDIAG_HATCH || (s)==wxHORIZONTAL_HATCH || (s)==wxVERTICAL_HATCH)
  45 #define IS_16_PIX_HATCH(s) ((s)!=wxCROSSDIAG_HATCH && (s)!=wxHORIZONTAL_HATCH && (s)!=wxVERTICAL_HATCH)
  46
  47 static Pixmap  hatches[num_hatches];
  48 static Pixmap *hatch_bitmap = (Pixmap *) NULL;
  49
  50 //-----------------------------------------------------------------------------
  51 // constants
  52 //-----------------------------------------------------------------------------
  53
  54 const double RAD2DEG  = 180.0 / M_PI;
  55
  56 // ----------------------------------------------------------------------------
  57 // private functions
  58 // ----------------------------------------------------------------------------
  59
  60 static inline double dmax(double a, double b) { return a > b ? a : b; }
  61 static inline double dmin(double a, double b) { return a < b ? a : b; }
  62
  63 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  64
  65 //-----------------------------------------------------------------------------
  66 // Implement Pool of Graphic contexts. Creating them takes too much time.
  67 //-----------------------------------------------------------------------------
  68
  69 #define GC_POOL_SIZE 200
  70
  71 enum wxPoolGCType
  72 {
  73    wxGC_ERROR = 0,
  74    wxTEXT_MONO,
  75    wxBG_MONO,
  76    wxPEN_MONO,
  77    wxBRUSH_MONO,
  78    wxTEXT_COLOUR,
  79    wxBG_COLOUR,
  80    wxPEN_COLOUR,
  81    wxBRUSH_COLOUR,
  82    wxTEXT_SCREEN,
  83    wxBG_SCREEN,
  84    wxPEN_SCREEN,
  85    wxBRUSH_SCREEN
  86 };
  87
  88 struct wxGC
  89 {
  90     GC            m_gc;
  91     wxPoolGCType  m_type;
  92     bool          m_used;
  93 };
  94
  95 static wxGC wxGCPool[GC_POOL_SIZE];
  96
  97 static void wxInitGCPool()
  98 {
  99     memset( wxGCPool, 0, GC_POOL_SIZE*sizeof(wxGC) );
 100 }
 101
 102 static void wxCleanUpGCPool()
 103 {
 104     for (int i = 0; i < GC_POOL_SIZE; i++)
 105     {
 106         if (wxGCPool[i].m_gc)
 107             XFreeGC( wxGlobalDisplay(), wxGCPool[i].m_gc );
 108     }
 109 }
 110
 111 static GC wxGetPoolGC( Window window, wxPoolGCType type )
 112 {
 113     for (int i = 0; i < GC_POOL_SIZE; i++)
 114     {
 115         if (!wxGCPool[i].m_gc)
 116         {
 117             wxGCPool[i].m_gc = XCreateGC( wxGlobalDisplay(), window, 0, NULL );
 118             XSetGraphicsExposures( wxGlobalDisplay(), wxGCPool[i].m_gc, FALSE );
 119             wxGCPool[i].m_type = type;
 120             wxGCPool[i].m_used = FALSE;
 121         }
 122         if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
 123         {
 124             wxGCPool[i].m_used = TRUE;
 125             return wxGCPool[i].m_gc;
 126         }
 127     }
 128
 129     wxFAIL_MSG( wxT("No GC available") );
 130
 131     return (GC) NULL;
 132 }
 133
 134 static void wxFreePoolGC( GC gc )
 135 {
 136     for (int i = 0; i < GC_POOL_SIZE; i++)
 137     {
 138         if (wxGCPool[i].m_gc == gc)
 139         {
 140             wxGCPool[i].m_used = FALSE;
 141             return;
 142         }
 143     }
 144
 145     wxFAIL_MSG( wxT("Wrong GC") );
 146 }
 147
 148 // ----------------------------------------------------------------------------
 149 // wxWindowDC
 150 // ----------------------------------------------------------------------------
 151
 152 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 153
 154 wxWindowDC::wxWindowDC()
 155 {
 156     m_display = (WXDisplay *) NULL;
 157     m_penGC = (WXGC *) NULL;
 158     m_brushGC = (WXGC *) NULL;
 159     m_textGC = (WXGC *) NULL;
 160     m_bgGC = (WXGC *) NULL;
 161     m_cmap = (WXColormap *) NULL;
 162     m_isMemDC = FALSE;
 163     m_isScreenDC = FALSE;
 164     m_owner = (wxWindow *)NULL;
 165 }
 166
 167 wxWindowDC::wxWindowDC( wxWindow *window )
 168 {
 169     wxASSERT_MSG( window, wxT("DC needs a window") );
 170
 171     m_display = (WXDisplay *) NULL;
 172     m_penGC = (WXGC *) NULL;
 173     m_brushGC = (WXGC *) NULL;
 174     m_textGC = (WXGC *) NULL;
 175     m_bgGC = (WXGC *) NULL;
 176     m_cmap = (WXColormap *) NULL;
 177     m_owner = (wxWindow *)NULL;
 178     m_isMemDC = FALSE;
 179     m_isScreenDC = FALSE;
 180     m_font = window->GetFont();
 181
 182     m_window = (WXWindow*) window->GetMainWindow();
 183
 184     // not realized ?
 185     if (!m_window)
 186     {
 187          // don't report problems
 188          m_ok = TRUE;
 189
 190          return;
 191     }
 192
 193     m_display = (WXDisplay *) wxGlobalDisplay();
 194
 195     int screen = DefaultScreen( (Display*) m_display );
 196     m_cmap = (WXColormap) DefaultColormap( (Display*) m_display, screen );
 197
 198     SetUpDC();
 199
 200     /* this must be done after SetUpDC, bacause SetUpDC calls the
 201        repective SetBrush, SetPen, SetBackground etc functions
 202        to set up the DC. SetBackground call m_owner->SetBackground
 203        and this might not be desired as the standard dc background
 204        is white whereas a window might assume gray to be the
 205        standard (as e.g. wxStatusBar) */
 206
 207     m_owner = window;
 208 }
 209
 210 wxWindowDC::~wxWindowDC()
 211 {
 212     Destroy();
 213 }
 214
 215 void wxWindowDC::SetUpDC()
 216 {
 217     m_ok = TRUE;
 218
 219     wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
 220
 221     if (m_isScreenDC)
 222     {
 223         m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_SCREEN );
 224         m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_SCREEN );
 225         m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_SCREEN );
 226         m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_SCREEN );
 227     }
 228 #if 0
 229     else
 230     if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
 231     {
 232         m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_MONO );
 233         m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_MONO );
 234         m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_MONO );
 235         m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_MONO );
 236     }
 237 #endif
 238     else
 239     {
 240         m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_COLOUR );
 241         m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_COLOUR );
 242         m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_COLOUR );
 243         m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_COLOUR );
 244     }
 245
 246     /* background colour */
 247     m_backgroundBrush = *wxWHITE_BRUSH;
 248     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
 249     unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
 250
 251     /* m_textGC */
 252     m_textForegroundColour.CalcPixel( m_cmap );
 253     XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
 254
 255     m_textBackgroundColour.CalcPixel( m_cmap );
 256     XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
 257
 258     XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillSolid );
 259
 260     /* m_penGC */
 261     m_pen.GetColour().CalcPixel( m_cmap );
 262     XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
 263     XSetBackground( (Display*) m_display, (GC) m_penGC, bg_col );
 264
 265     XSetLineAttributes( (Display*) m_display, (GC) m_penGC, 0, LineSolid, CapNotLast, JoinRound );
 266
 267     /* m_brushGC */
 268     m_brush.GetColour().CalcPixel( m_cmap );
 269     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
 270     XSetBackground( (Display*) m_display, (GC) m_brushGC, bg_col );
 271
 272     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
 273
 274     /* m_bgGC */
 275     XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
 276     XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );
 277
 278     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 279
 280     /* ROPs */
 281     XSetFunction( (Display*) m_display, (GC) m_textGC, GXcopy );
 282     XSetFunction( (Display*) m_display, (GC) m_brushGC, GXcopy );
 283     XSetFunction( (Display*) m_display, (GC)m_penGC, GXcopy );
 284
 285     /* clipping */
 286     XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
 287     XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
 288     XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
 289     XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
 290
 291     if (!hatch_bitmap)
 292     {
 293         int xscreen = DefaultScreen( (Display*) m_display );
 294         Window xroot = RootWindow( (Display*) m_display, xscreen );
 295
 296         hatch_bitmap    = hatches;
 297         hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
 298         hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );
 299         hatch_bitmap[2] = XCreateBitmapFromData( (Display*) m_display, xroot, fdiag_bits, fdiag_width, fdiag_height );
 300         hatch_bitmap[3] = XCreateBitmapFromData( (Display*) m_display, xroot, cross_bits, cross_width, cross_height );
 301         hatch_bitmap[4] = XCreateBitmapFromData( (Display*) m_display, xroot, horiz_bits, horiz_width, horiz_height );
 302         hatch_bitmap[5] = XCreateBitmapFromData( (Display*) m_display, xroot, verti_bits, verti_width, verti_height );
 303     }
 304 }
 305
 306 void wxWindowDC::DoGetSize( int* width, int* height ) const
 307 {
 308     wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
 309
 310     m_owner->GetSize(width, height);
 311 }
 312
 313 void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
 314                            const wxColour& WXUNUSED(col), int WXUNUSED(style) )
 315 {
 316     wxFAIL_MSG("not implemented");
 317 }
 318
 319 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 320 {
 321     // Generic (and therefore rather inefficient) method.
 322     // Could be improved.
 323     wxMemoryDC memdc;
 324     wxBitmap bitmap(1, 1);
 325     memdc.SelectObject(bitmap);
 326     memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
 327     memdc.SelectObject(wxNullBitmap);
 328     wxImage image(bitmap);
 329     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
 330     return TRUE;
 331 }
 332
 333 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 334 {
 335     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 336
 337     if (m_pen.GetStyle() != wxTRANSPARENT)
 338     {
 339         if (m_window)
 340             XDrawLine( (Display*) m_display, (Window) m_window,
 341                 (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
 342
 343         CalcBoundingBox(x1, y1);
 344         CalcBoundingBox(x2, y2);
 345
 346         wxLogDebug("Drawing line at %d, %d -> %d, %d", XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
 347     }
 348 }
 349
 350 void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
 351 {
 352     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 353
 354     if (m_pen.GetStyle() != wxTRANSPARENT)
 355     {
 356         int w = 0;
 357         int h = 0;
 358         GetSize( &w, &h );
 359         wxCoord xx = XLOG2DEV(x);
 360         wxCoord yy = YLOG2DEV(y);
 361         if (m_window)
 362         {
 363             XDrawLine( (Display*) m_display, (Window) m_window,
 364                 (GC) m_penGC, 0, yy, XLOG2DEVREL(w), yy );
 365             XDrawLine( (Display*) m_display, (Window) m_window,
 366                 (GC) m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
 367         }
 368     }
 369 }
 370
 371 void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
 372 {
 373     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 374
 375     wxCoord xx1 = XLOG2DEV(x1);
 376     wxCoord yy1 = YLOG2DEV(y1);
 377     wxCoord xx2 = XLOG2DEV(x2);
 378     wxCoord yy2 = YLOG2DEV(y2);
 379     wxCoord xxc = XLOG2DEV(xc);
 380     wxCoord yyc = YLOG2DEV(yc);
 381     double dx = xx1 - xxc;
 382     double dy = yy1 - yyc;
 383     double radius = sqrt((double)(dx*dx+dy*dy));
 384     wxCoord   r      = (wxCoord)radius;
 385     double radius1, radius2;
 386
 387     if (xx1 == xx2 && yy1 == yy2)
 388     {
 389         radius1 = 0.0;
 390         radius2 = 360.0;
 391     }
 392     else
 393     if (radius == 0.0)
 394     {
 395         radius1 = radius2 = 0.0;
 396     }
 397     else
 398     {
 399         radius1 = (xx1 - xxc == 0) ?
 400             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 401             -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
 402         radius2 = (xx2 - xxc == 0) ?
 403             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 404             -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
 405     }
 406     wxCoord alpha1 = wxCoord(radius1 * 64.0);
 407     wxCoord alpha2 = wxCoord((radius2 - radius1) * 64.0);
 408     while (alpha2 <= 0) alpha2 += 360*64;
 409     while (alpha1 > 360*64) alpha1 -= 360*64;
 410
 411     if (m_window)
 412     {
 413         if (m_brush.GetStyle() != wxTRANSPARENT)
 414         {
 415             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 416             {
 417                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 418                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 419                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 420
 421                 XFillArc( (Display*) m_display, (Window) m_window,
 422                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 423
 424                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 425             } else
 426             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 427             {
 428                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 429                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 430
 431                 XFillArc( (Display*) m_display, (Window) m_window,
 432                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 433
 434                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 435             } else
 436             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 437             {
 438                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 439                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 440
 441                 XFillArc( (Display*) m_display, (Window) m_window,
 442                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 443
 444                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 445             } else
 446             if (m_brush.GetStyle() == wxSTIPPLE)
 447             {
 448                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 449                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 450                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 451
 452                 XFillArc( (Display*) m_display, (Window) m_window,
 453                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 454
 455                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 456             }
 457             else
 458             {
 459                 XFillArc( (Display*) m_display, (Window) m_window,
 460                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 461             }
 462         }
 463
 464         if (m_pen.GetStyle() != wxTRANSPARENT)
 465         {
 466             XDrawArc( (Display*) m_display, (Window) m_window,
 467                (GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 468
 469             XDrawLine( (Display*) m_display, (Window) m_window,
 470                (GC) m_penGC, xx1, yy1, xxc, yyc );
 471
 472             XDrawLine( (Display*) m_display, (Window) m_window,
 473                (GC) m_penGC, xxc, yyc, xx2, yy2 );
 474         }
 475     }
 476
 477     CalcBoundingBox (x1, y1);
 478     CalcBoundingBox (x2, y2);
 479 }
 480
 481 void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
 482 {
 483     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 484
 485     wxCoord xx = XLOG2DEV(x);
 486     wxCoord yy = YLOG2DEV(y);
 487     wxCoord ww = m_signX * XLOG2DEVREL(width);
 488     wxCoord hh = m_signY * YLOG2DEVREL(height);
 489
 490     // CMB: handle -ve width and/or height
 491     if (ww < 0) { ww = -ww; xx = xx - ww; }
 492     if (hh < 0) { hh = -hh; yy = yy - hh; }
 493
 494     if (m_window)
 495     {
 496         wxCoord start = wxCoord(sa * 64.0);
 497         wxCoord end = wxCoord((ea-sa) * 64.0);
 498
 499         if (m_brush.GetStyle() != wxTRANSPARENT)
 500         {
 501             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 502             {
 503                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 504                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 505                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 506
 507                 XFillArc( (Display*) m_display, (Window) m_window,
 508                     (GC) m_textGC, xx, yy, ww, hh, start, end );
 509
 510                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 511             } else
 512             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 513             {
 514                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 515                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 516
 517                 XFillArc( (Display*) m_display, (Window) m_window,
 518                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 519
 520                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 521             } else
 522             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 523             {
 524                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 525                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 526
 527                 XFillArc( (Display*) m_display, (Window) m_window,
 528                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 529
 530                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 531             } else
 532             if (m_brush.GetStyle() == wxSTIPPLE)
 533             {
 534                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 535                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 536                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 537
 538                 XFillArc( (Display*) m_display, (Window) m_window,
 539                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 540
 541                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 542             }
 543             else
 544             {
 545                 XFillArc( (Display*) m_display, (Window) m_window,
 546                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 547             }
 548         }
 549
 550         if (m_pen.GetStyle() != wxTRANSPARENT)
 551         {
 552             XDrawArc( (Display*) m_display, (Window) m_window,
 553                 (GC) m_penGC, xx, yy, ww, hh, start, end );
 554         }
 555     }
 556
 557     CalcBoundingBox (x, y);
 558     CalcBoundingBox (x + width, y + height);
 559 }
 560
 561 void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
 562 {
 563     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 564
 565     if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
 566         XDrawPoint( (Display*) m_display, (Window) m_window,
 567                 (GC) m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 568
 569     CalcBoundingBox (x, y);
 570 }
 571
 572 void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
 573 {
 574     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 575
 576     if (m_pen.GetStyle() == wxTRANSPARENT) return;
 577     if (n <= 0) return;
 578
 579     XPoint *xpoints = new XPoint[n];
 580     for (int i = 0; i < n; i++)
 581     {
 582         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
 583         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
 584
 585         CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
 586     }
 587     XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n, 0 );
 588
 589     delete[] xpoints;
 590 }
 591
 592 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
 593                                 wxCoord xoffset, wxCoord yoffset, int fillStyle )
 594 {
 595     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 596
 597     if (n <= 0) return;
 598
 599     XPoint *xpoints = new XPoint[n + 1];
 600     int i;
 601     for (i = 0; i < n; i++)
 602     {
 603         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
 604         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
 605
 606         CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
 607     }
 608
 609     if (m_window)
 610     {
 611         if (m_brush.GetStyle() != wxTRANSPARENT)
 612         {
 613
 614             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 615             {
 616                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 617                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 618                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 619
 620                 XFillPolygon( (Display*) m_display, (Window) m_window,
 621                     (GC) m_textGC, xpoints, n, Complex, 0);
 622
 623                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 624             } else
 625             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 626             {
 627                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 628                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 629
 630                 XFillPolygon( (Display*) m_display, (Window) m_window,
 631                     (GC) m_brushGC, xpoints, n, Complex, 0);
 632
 633                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 634             } else
 635             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 636             {
 637                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 638                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 639
 640                 XFillPolygon( (Display*) m_display, (Window) m_window,
 641                     (GC) m_brushGC, xpoints, n, Complex, 0);
 642
 643                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 644             } else
 645             if (m_brush.GetStyle() == wxSTIPPLE)
 646             {
 647                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 648                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 649                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 650
 651                 XFillPolygon( (Display*) m_display, (Window) m_window,
 652                     (GC) m_brushGC, xpoints, n, Complex, 0);
 653
 654                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 655             }
 656             else
 657             {
 658                 XFillPolygon( (Display*) m_display, (Window) m_window,
 659                     (GC) m_brushGC, xpoints, n, Complex, 0);
 660             }
 661         }
 662
 663         if (m_pen.GetStyle () != wxTRANSPARENT)
 664         {
 665             // Close figure for XDrawLines
 666             xpoints[i].x = xpoints[0].x;
 667             xpoints[i].y = xpoints[0].y;
 668
 669             XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n + 1, 0);
 670         }
 671     }
 672
 673     delete[] xpoints;
 674 }
 675
 676 void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 677 {
 678     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 679
 680     wxCoord xx = XLOG2DEV(x);
 681     wxCoord yy = YLOG2DEV(y);
 682     wxCoord ww = m_signX * XLOG2DEVREL(width);
 683     wxCoord hh = m_signY * YLOG2DEVREL(height);
 684
 685     // CMB: draw nothing if transformed w or h is 0
 686     if (ww == 0 || hh == 0) return;
 687
 688     // CMB: handle -ve width and/or height
 689     if (ww < 0) { ww = -ww; xx = xx - ww; }
 690     if (hh < 0) { hh = -hh; yy = yy - hh; }
 691
 692     if (m_window)
 693     {
 694         if (m_brush.GetStyle() != wxTRANSPARENT)
 695         {
 696             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 697             {
 698                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 699                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 700                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 701
 702                 XFillRectangle( (Display*) m_display, (Window) m_window,
 703                     (GC) m_textGC, xx, yy, ww, hh );
 704
 705                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 706             } else
 707             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 708             {
 709                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 710                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 711
 712                 XFillRectangle( (Display*) m_display, (Window) m_window,
 713                     (GC) m_brushGC, xx, yy, ww, hh );
 714
 715                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 716             } else
 717             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 718             {
 719                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 720                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 721
 722                 XFillRectangle( (Display*) m_display, (Window) m_window,
 723                     (GC) m_brushGC, xx, yy, ww, hh );
 724
 725                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 726             } else
 727             if (m_brush.GetStyle() == wxSTIPPLE)
 728             {
 729                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 730                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 731                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 732
 733                 XFillRectangle( (Display*) m_display, (Window) m_window,
 734                     (GC) m_brushGC, xx, yy, ww, hh );
 735
 736                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 737             }
 738             else
 739             {
 740                 XFillRectangle( (Display*) m_display, (Window) m_window,
 741                     (GC) m_brushGC, xx, yy, ww, hh );
 742             }
 743         }
 744
 745         if (m_pen.GetStyle () != wxTRANSPARENT)
 746         {
 747             XDrawRectangle( (Display*) m_display, (Window) m_window,
 748                 (GC) m_penGC, xx, yy, ww, hh );
 749         }
 750     }
 751
 752     CalcBoundingBox( x, y );
 753     CalcBoundingBox( x + width, y + height );
 754     wxLogDebug("Drawing rectangle at %d, %d (%dx%d)", x, y, width, height);
 755 }
 756
 757 void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
 758 {
 759    // later
 760 }
 761
 762 void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 763 {
 764     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 765
 766     wxCoord xx = XLOG2DEV(x);
 767     wxCoord yy = YLOG2DEV(y);
 768     wxCoord ww = m_signX * XLOG2DEVREL(width);
 769     wxCoord hh = m_signY * YLOG2DEVREL(height);
 770
 771     // CMB: handle -ve width and/or height
 772     if (ww < 0) { ww = -ww; xx = xx - ww; }
 773     if (hh < 0) { hh = -hh; yy = yy - hh; }
 774
 775     if (m_window)
 776     {
 777         if (m_brush.GetStyle() != wxTRANSPARENT)
 778         {
 779             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 780             {
 781                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 782                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 783                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 784
 785                 XFillArc( (Display*) m_display, (Window) m_window,
 786                     (GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );
 787
 788                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 789             } else
 790             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 791             {
 792                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 793                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 794
 795                 XFillArc( (Display*) m_display, (Window) m_window,
 796                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 797
 798                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 799             } else
 800             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 801             {
 802                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 803                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 804
 805                 XFillArc( (Display*) m_display, (Window) m_window,
 806                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 807
 808                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 809             } else
 810             if (m_brush.GetStyle() == wxSTIPPLE)
 811             {
 812                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 813                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 814                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 815
 816                 XFillArc( (Display*) m_display, (Window) m_window,
 817                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 818
 819                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 820             }
 821             else
 822             {
 823                 XFillArc( (Display*) m_display, (Window) m_window,
 824                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 825             }
 826         }
 827
 828         if (m_pen.GetStyle () != wxTRANSPARENT)
 829         {
 830             XDrawArc( (Display*) m_display, (Window) m_window,
 831                 (GC) m_penGC, xx, yy, ww, hh, 0, 360*64 );
 832         }
 833     }
 834
 835     CalcBoundingBox( x, y );
 836     CalcBoundingBox( x + width, y + height );
 837 }
 838
 839 void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
 840 {
 841 }
 842
 843 void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
 844                                wxCoord x, wxCoord y,
 845                                bool useMask )
 846 {
 847     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 848
 849     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
 850
 851 #if 0
 852     bool is_mono = (bitmap.GetBitmap() != NULL);
 853
 854     /* scale/translate size and position */
 855     int xx = XLOG2DEV(x);
 856     int yy = YLOG2DEV(y);
 857
 858     int w = bitmap.GetWidth();
 859     int h = bitmap.GetHeight();
 860
 861     CalcBoundingBox( x, y );
 862     CalcBoundingBox( x + w, y + h );
 863
 864     if (!m_window) return;
 865
 866     int ww = XLOG2DEVREL(w);
 867     int hh = YLOG2DEVREL(h);
 868
 869     /* compare to current clipping region */
 870     if (!m_currentClippingRegion.IsNull())
 871     {
 872         wxRegion tmp( xx,yy,ww,hh );
 873         tmp.Intersect( m_currentClippingRegion );
 874         if (tmp.IsEmpty())
 875             return;
 876     }
 877
 878     /* scale bitmap if required */
 879     wxBitmap use_bitmap;
 880     if ((w != ww) || (h != hh))
 881     {
 882         wxImage image( bitmap );
 883         image.Rescale( ww, hh );
 884         if (is_mono)
 885             use_bitmap = image.ConvertToMonoBitmap(255,255,255);
 886         else
 887             use_bitmap = image.ConvertToBitmap();
 888     }
 889     else
 890     {
 891         use_bitmap = bitmap;
 892     }
 893
 894     /* apply mask if any */
 895     GdkBitmap *mask = (GdkBitmap *) NULL;
 896     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
 897
 898         if (useMask && mask)
 899         {
 900             GdkBitmap *new_mask = (GdkBitmap*) NULL;
 901             if (!m_currentClippingRegion.IsNull())
 902             {
 903                 GdkColor col;
 904                 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, ww, hh, 1 );
 905                 GdkGC *gc = gdk_gc_new( new_mask );
 906                 col.pixel = 0;
 907                 gdk_gc_set_foreground( gc, &col );
 908                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
 909                 col.pixel = 0;
 910                 gdk_gc_set_background( gc, &col );
 911                 col.pixel = 1;
 912                 gdk_gc_set_foreground( gc, &col );
 913                 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
 914                 gdk_gc_set_clip_origin( gc, -xx, -yy );
 915                 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
 916                 gdk_gc_set_stipple( gc, mask );
 917                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
 918                 gdk_gc_unref( gc );
 919             }
 920
 921             if (is_mono)
 922             {
 923                 if (new_mask)
 924                     gdk_gc_set_clip_mask( m_textGC, new_mask );
 925                 else
 926                     gdk_gc_set_clip_mask( m_textGC, mask );
 927                 gdk_gc_set_clip_origin( m_textGC, xx, yy );
 928             }
 929             else
 930             {
 931                 if (new_mask)
 932                     gdk_gc_set_clip_mask( m_penGC, new_mask );
 933                 else
 934                     gdk_gc_set_clip_mask( m_penGC, mask );
 935                 gdk_gc_set_clip_origin( m_penGC, xx, yy );
 936             }
 937             if (new_mask)
 938                 gdk_bitmap_unref( new_mask );
 939         }
 940
 941     /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
 942        drawing a mono-bitmap (XBitmap) we use the current text GC */
 943     if (is_mono)
 944         gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), 0, 0, xx, yy, -1, -1 );
 945     else
 946         gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
 947
 948     /* remove mask again if any */
 949     if (useMask && mask)
 950     {
 951         if (is_mono)
 952         {
 953             gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
 954             gdk_gc_set_clip_origin( m_textGC, 0, 0 );
 955             if (!m_currentClippingRegion.IsNull())
 956                 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
 957         }
 958         else
 959         {
 960             gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
 961             gdk_gc_set_clip_origin( m_penGC, 0, 0 );
 962             if (!m_currentClippingRegion.IsNull())
 963                 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
 964         }
 965     }
 966 #endif
 967 }
 968
 969 bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 970                          wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
 971                          wxCoord xsrcMask, wxCoord ysrcMask )
 972 {
 973    /* this is the nth try to get this utterly useless function to
 974       work. it now completely ignores the scaling or translation
 975       of the source dc, but scales correctly on the target dc and
 976       knows about possible mask information in a memory dc. */
 977
 978     wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
 979
 980     wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
 981
 982     if (!m_window) return FALSE;
 983
 984     // transform the source DC coords to the device ones
 985     xsrc = source->XLOG2DEV(xsrc);
 986     ysrc = source->YLOG2DEV(ysrc);
 987
 988     wxClientDC *srcDC = (wxClientDC*)source;
 989     wxMemoryDC *memDC = (wxMemoryDC*)source;
 990
 991     bool use_bitmap_method = FALSE;
 992     bool is_mono = FALSE;
 993
 994     /* TODO: use the mask origin when drawing transparently */
 995     if (xsrcMask == -1 && ysrcMask == -1)
 996     {
 997         xsrcMask = xsrc; ysrcMask = ysrc;
 998     }
 999
1000 #if 0
1001     if (srcDC->m_isMemDC)
1002     {
1003         if (!memDC->m_selected.Ok()) return FALSE;
1004
1005         /* we use the "XCopyArea" way to copy a memory dc into
1006            y different window if the memory dc BOTH
1007            a) doesn't have any mask or its mask isn't used
1008            b) it is clipped
1009            c) is not 1-bit */
1010
1011         if (useMask && (memDC->m_selected.GetMask()))
1012         {
1013            /* we HAVE TO use the direct way for memory dcs
1014               that have mask since the XCopyArea doesn't know
1015               about masks */
1016             use_bitmap_method = TRUE;
1017         }
1018         else if (memDC->m_selected.GetDepth() == 1)
1019         {
1020            /* we HAVE TO use the direct way for memory dcs
1021               that are bitmaps because XCopyArea doesn't cope
1022               with different bit depths */
1023             is_mono = TRUE;
1024             use_bitmap_method = TRUE;
1025         }
1026         else if ((xsrc == 0) && (ysrc == 0) &&
1027                  (width == memDC->m_selected.GetWidth()) &&
1028                  (height == memDC->m_selected.GetHeight()))
1029         {
1030            /* we SHOULD use the direct way if all of the bitmap
1031               in the memory dc is copied in which case XCopyArea
1032               wouldn't be able able to boost performace by reducing
1033               the area to be scaled */
1034             use_bitmap_method = TRUE;
1035         }
1036         else
1037         {
1038             use_bitmap_method = FALSE;
1039         }
1040     }
1041
1042     CalcBoundingBox( xdest, ydest );
1043     CalcBoundingBox( xdest + width, ydest + height );
1044
1045     /* scale/translate size and position */
1046     wxCoord xx = XLOG2DEV(xdest);
1047     wxCoord yy = YLOG2DEV(ydest);
1048
1049     wxCoord ww = XLOG2DEVREL(width);
1050     wxCoord hh = YLOG2DEVREL(height);
1051
1052     /* compare to current clipping region */
1053     if (!m_currentClippingRegion.IsNull())
1054     {
1055         wxRegion tmp( xx,yy,ww,hh );
1056         tmp.Intersect( m_currentClippingRegion );
1057         if (tmp.IsEmpty())
1058             return TRUE;
1059     }
1060
1061     int old_logical_func = m_logicalFunction;
1062     SetLogicalFunction( logical_func );
1063
1064     if (use_bitmap_method)
1065     {
1066         /* scale/translate bitmap size */
1067         wxCoord bm_width = memDC->m_selected.GetWidth();
1068         wxCoord bm_height = memDC->m_selected.GetHeight();
1069
1070         wxCoord bm_ww = XLOG2DEVREL( bm_width );
1071         wxCoord bm_hh = YLOG2DEVREL( bm_height );
1072
1073         /* scale bitmap if required */
1074         wxBitmap use_bitmap;
1075
1076         if ((bm_width != bm_ww) || (bm_height != bm_hh))
1077         {
1078             wxImage image( memDC->m_selected );
1079             image = image.Scale( bm_ww, bm_hh );
1080
1081             if (is_mono)
1082                 use_bitmap = image.ConvertToMonoBitmap(255,255,255);
1083             else
1084                 use_bitmap = image.ConvertToBitmap();
1085         }
1086         else
1087         {
1088             use_bitmap = memDC->m_selected;
1089         }
1090
1091         /* apply mask if any */
1092         GdkBitmap *mask = (GdkBitmap *) NULL;
1093         if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
1094
1095         if (useMask && mask)
1096         {
1097             GdkBitmap *new_mask = (GdkBitmap*) NULL;
1098             if (!m_currentClippingRegion.IsNull())
1099             {
1100                 GdkColor col;
1101                 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, bm_ww, bm_hh, 1 );
1102                 GdkGC *gc = gdk_gc_new( new_mask );
1103                 col.pixel = 0;
1104                 gdk_gc_set_foreground( gc, &col );
1105                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1106                 col.pixel = 0;
1107                 gdk_gc_set_background( gc, &col );
1108                 col.pixel = 1;
1109                 gdk_gc_set_foreground( gc, &col );
1110                 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1111                 gdk_gc_set_clip_origin( gc, -xx, -yy );
1112                 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1113                 gdk_gc_set_stipple( gc, mask );
1114                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1115                 gdk_gc_unref( gc );
1116             }
1117
1118             if (is_mono)
1119             {
1120                 if (new_mask)
1121                     gdk_gc_set_clip_mask( m_textGC, new_mask );
1122                 else
1123                     gdk_gc_set_clip_mask( m_textGC, mask );
1124                 gdk_gc_set_clip_origin( m_textGC, xx, yy );
1125             }
1126             else
1127             {
1128                 if (new_mask)
1129                     gdk_gc_set_clip_mask( m_penGC, new_mask );
1130                 else
1131                     gdk_gc_set_clip_mask( m_penGC, mask );
1132                 gdk_gc_set_clip_origin( m_penGC, xx, yy );
1133             }
1134             if (new_mask)
1135                 gdk_bitmap_unref( new_mask );
1136         }
1137
1138         /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1139            drawing a mono-bitmap (XBitmap) we use the current text GC */
1140
1141         if (is_mono)
1142             gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), xsrc, ysrc, xx, yy, ww, hh );
1143         else
1144             gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
1145
1146         /* remove mask again if any */
1147         if (useMask && mask)
1148         {
1149             if (is_mono)
1150             {
1151                 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1152                 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
1153                 if (!m_currentClippingRegion.IsNull())
1154                     gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1155             }
1156             else
1157             {
1158                 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1159                 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
1160                 if (!m_currentClippingRegion.IsNull())
1161                     gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1162             }
1163         }
1164     }
1165     else /* use_bitmap_method */
1166     {
1167         if ((width != ww) || (height != hh))
1168         {
1169             /* draw source window into a bitmap as we cannot scale
1170                a window in contrast to a bitmap. this would actually
1171                work with memory dcs as well, but we'd lose the mask
1172                information and waste one step in this process since
1173                a memory already has a bitmap. all this is slightly
1174                inefficient as we could take an XImage directly from
1175                an X window, but we'd then also have to care that
1176                the window is not outside the screen (in which case
1177                we'd get a BadMatch or what not).
1178                Is a double XGetImage and combined XGetPixel and
1179                XPutPixel really faster? I'm not sure. look at wxXt
1180                for a different implementation of the same problem. */
1181
1182             wxBitmap bitmap( width, height );
1183
1184             /* copy including child window contents */
1185             gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1186             gdk_window_copy_area( bitmap.GetPixmap(), m_penGC, 0, 0,
1187                                   srcDC->GetWindow(),
1188                                   xsrc, ysrc, width, height );
1189             gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1190
1191             /* scale image */
1192             wxImage image( bitmap );
1193             image = image.Scale( ww, hh );
1194
1195             /* convert to bitmap */
1196             bitmap = image.ConvertToBitmap();
1197
1198             /* draw scaled bitmap */
1199             gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
1200
1201         }
1202         else
1203         {
1204             /* No scaling and not a memory dc with a mask either */
1205
1206             /* copy including child window contents */
1207             gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1208             gdk_window_copy_area( m_window, m_penGC, xx, yy,
1209                                   srcDC->GetWindow(),
1210                                   xsrc, ysrc, width, height );
1211             gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1212         }
1213     }
1214
1215     SetLogicalFunction( old_logical_func );
1216     return TRUE;
1217 #endif
1218
1219     return FALSE;
1220 }
1221
1222 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
1223 {
1224     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1225
1226     if (!m_window) return;
1227
1228     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1229
1230     wxCHECK_RET( xfont, wxT("invalid font") );
1231
1232     x = XLOG2DEV(x);
1233     y = YLOG2DEV(y);
1234
1235     XCharStruct overall_return;
1236     int direction = 0;
1237     int slen = text.Length();
1238     int ascent = 0;
1239     int descent = 0;
1240     (void)XTextExtents((XFontStruct*) xfont, (char*) (const char*) text, slen, &direction,
1241                                &ascent, &descent, &overall_return);
1242 #if 0
1243     wxCoord width = gdk_string_width( font, text.mbc_str() );
1244     wxCoord height = font->ascent + font->descent;
1245
1246     if ( m_backgroundMode == wxSOLID )
1247     {
1248         gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
1249         gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
1250         gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1251     }
1252 #endif
1253
1254     XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
1255     if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
1256         {
1257         XDrawString( (Display*) m_display, (Window) m_window,
1258             (GC) m_textGC, x, y + ascent, text.c_str(), text.Len() );
1259         wxLogDebug("Drawing text %s at %d, %d", text.c_str(), x, y);
1260         }
1261
1262 #if 0
1263     if (m_font.GetUnderlined())
1264     {
1265         wxCoord ul_y = y + font->ascent;
1266         if (font->descent > 0) ul_y++;
1267         gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
1268     }
1269
1270     width = wxCoord(width / m_scaleX);
1271     height = wxCoord(height / m_scaleY);
1272
1273     CalcBoundingBox (x + width, y + height);
1274     CalcBoundingBox (x, y);
1275 #endif
1276 }
1277
1278 void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1279 {
1280     // later
1281 }
1282
1283 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
1284                                 wxCoord *descent, wxCoord *externalLeading,
1285                                 wxFont *font ) const
1286 {
1287     wxCHECK_RET( Ok(), "invalid dc" );
1288
1289     wxFont fontToUse = m_font;
1290     if (font) fontToUse = *font;
1291
1292     wxCHECK_RET( fontToUse.Ok(), "invalid font" );
1293
1294     XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
1295
1296     wxCHECK_RET( xfont, wxT("invalid font") );
1297
1298     int direction, ascent, descent2;
1299     XCharStruct overall;
1300
1301     XTextExtents( xfont, string.c_str(), string.Len(), &direction,
1302         &ascent, &descent2, &overall);
1303
1304     if (width)
1305         *width = (wxCoord)( overall.width / m_scaleX );
1306     if (height)
1307         *height = (wxCoord)((ascent + descent2) / m_scaleY );
1308     if (descent)
1309         *descent = (wxCoord)(descent2 / m_scaleY );
1310     if (externalLeading)
1311         *externalLeading = 0; // ??
1312 }
1313
1314 wxCoord wxWindowDC::GetCharWidth() const
1315 {
1316     wxCHECK_MSG( Ok(), 0, "invalid dc" );
1317
1318     wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1319
1320     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1321
1322     wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1323
1324     int direction, ascent, descent;
1325     XCharStruct overall;
1326
1327     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1328
1329     return (wxCoord)(overall.width / m_scaleX);
1330 }
1331
1332 wxCoord wxWindowDC::GetCharHeight() const
1333 {
1334     wxCHECK_MSG( Ok(), 0, "invalid dc" );
1335
1336     wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1337
1338     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1339
1340     wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1341
1342     int direction, ascent, descent;
1343     XCharStruct overall;
1344
1345     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1346
1347     return (wxCoord)((ascent+descent) / m_scaleY);
1348 }
1349
1350 void wxWindowDC::Clear()
1351 {
1352     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1353
1354     if (!m_window) return;
1355
1356     /* - we either are a memory dc or have a window as the
1357        owner. anything else shouldn't happen.
1358        - we don't use gdk_window_clear() as we don't set
1359        the window's background colour anymore. it is too
1360        much pain to keep the DC's and the window's back-
1361        ground colour in synch. */
1362
1363     if (m_owner)
1364     {
1365         int width,height;
1366         m_owner->GetSize( &width, &height );
1367         XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1368         return;
1369     }
1370
1371     if (m_isMemDC)
1372     {
1373         int width,height;
1374         GetSize( &width, &height );
1375         XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1376         return;
1377     }
1378 }
1379
1380 void wxWindowDC::SetFont( const wxFont &font )
1381 {
1382     wxCHECK_RET( Ok(), "invalid dc" );
1383
1384     m_font = font;
1385 }
1386
1387 void wxWindowDC::SetPen( const wxPen &pen )
1388 {
1389     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1390
1391     if (m_pen == pen) return;
1392
1393     m_pen = pen;
1394
1395     if (!m_pen.Ok()) return;
1396
1397     if (!m_window) return;
1398
1399     int width = m_pen.GetWidth();
1400     if (width <= 0)
1401     {
1402         // CMB: if width is non-zero scale it with the dc
1403         width = 1;
1404     }
1405     else
1406     {
1407         // X doesn't allow different width in x and y and so we take
1408         // the average
1409         double w = 0.5 +
1410                    ( fabs((double) XLOG2DEVREL(width)) +
1411                      fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1412         width = (int)w;
1413     }
1414
1415     static const wxX11Dash dotted[] = {1, 1};
1416     static const wxX11Dash short_dashed[] = {2, 2};
1417     static const wxX11Dash long_dashed[] = {2, 4};
1418     static const wxX11Dash dotted_dashed[] = {3, 3, 1, 3};
1419
1420     // We express dash pattern in pen width unit, so we are
1421     // independent of zoom factor and so on...
1422     int req_nb_dash;
1423     const wxX11Dash *req_dash;
1424
1425     int lineStyle = LineSolid;
1426     switch (m_pen.GetStyle())
1427     {
1428         case wxUSER_DASH:
1429         {
1430             lineStyle = LineOnOffDash;
1431             req_nb_dash = m_pen.GetDashCount();
1432             req_dash = (wxX11Dash*)m_pen.GetDash();
1433             break;
1434         }
1435         case wxDOT:
1436         {
1437             lineStyle = LineOnOffDash;
1438             req_nb_dash = 2;
1439             req_dash = dotted;
1440             break;
1441         }
1442         case wxLONG_DASH:
1443         {
1444             lineStyle = LineOnOffDash;
1445             req_nb_dash = 2;
1446             req_dash = long_dashed;
1447             break;
1448         }
1449         case wxSHORT_DASH:
1450         {
1451             lineStyle = LineOnOffDash;
1452             req_nb_dash = 2;
1453             req_dash = short_dashed;
1454             break;
1455         }
1456         case wxDOT_DASH:
1457         {
1458 //            lineStyle = LineDoubleDash;
1459             lineStyle = LineOnOffDash;
1460             req_nb_dash = 4;
1461             req_dash = dotted_dashed;
1462             break;
1463         }
1464
1465         case wxTRANSPARENT:
1466         case wxSTIPPLE_MASK_OPAQUE:
1467         case wxSTIPPLE:
1468         case wxSOLID:
1469         default:
1470         {
1471             lineStyle = LineSolid;
1472             req_dash = (wxX11Dash*)NULL;
1473             req_nb_dash = 0;
1474             break;
1475         }
1476     }
1477
1478     int capStyle = CapRound;
1479     switch (m_pen.GetCap())
1480     {
1481         case wxCAP_PROJECTING: { capStyle = CapProjecting; break; }
1482         case wxCAP_BUTT:       { capStyle = CapButt;       break; }
1483         case wxCAP_ROUND:
1484         default:
1485         {
1486             if (width <= 1)
1487             {
1488                 width = 0;
1489                 capStyle = CapNotLast;
1490             }
1491             else
1492             {
1493                 capStyle = CapRound;
1494             }
1495             break;
1496         }
1497     }
1498
1499     int joinStyle = JoinRound;
1500     switch (m_pen.GetJoin())
1501     {
1502         case wxJOIN_BEVEL: { joinStyle = JoinBevel; break; }
1503         case wxJOIN_MITER: { joinStyle = JoinMiter; break; }
1504         case wxJOIN_ROUND:
1505         default:           { joinStyle = JoinRound; break; }
1506     }
1507
1508     XSetLineAttributes( (Display*) m_display, (GC) m_penGC, width, lineStyle, capStyle, joinStyle );
1509
1510     m_pen.GetColour().CalcPixel( m_cmap );
1511     XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
1512 }
1513
1514 void wxWindowDC::SetBrush( const wxBrush &brush )
1515 {
1516     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1517
1518     if (m_brush == brush) return;
1519
1520     m_brush = brush;
1521
1522     if (!m_brush.Ok()) return;
1523
1524     if (!m_window) return;
1525
1526     m_brush.GetColour().CalcPixel( m_cmap );
1527     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
1528
1529     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
1530
1531     if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1532     {
1533         if (m_brush.GetStipple()->GetPixmap())
1534         {
1535             XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillTiled );
1536             XSetTile( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetPixmap() );
1537         }
1538         else
1539         {
1540             XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1541 //            XSetStipple( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetBitmap() );
1542         }
1543     }
1544
1545     if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1546     {
1547         XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillOpaqueStippled );
1548 //        XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
1549     }
1550
1551     if (IS_HATCH(m_brush.GetStyle()))
1552     {
1553         XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1554         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1555         XSetStipple( (Display*) m_display, (GC) m_brushGC, hatches[num] );
1556     }
1557 }
1558
1559 void wxWindowDC::SetBackground( const wxBrush &brush )
1560 {
1561    /* CMB 21/7/98: Added SetBackground. Sets background brush
1562     * for Clear() and bg colour for shapes filled with cross-hatch brush */
1563
1564     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1565
1566     if (m_backgroundBrush == brush) return;
1567
1568     m_backgroundBrush = brush;
1569
1570     if (!m_backgroundBrush.Ok()) return;
1571
1572     if (!m_window) return;
1573
1574     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1575     XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );
1576     XSetBackground( (Display*) m_display, (GC) m_penGC, m_backgroundBrush.GetColour().GetPixel() );
1577     XSetBackground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1578     XSetForeground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1579
1580     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
1581
1582     if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1583     {
1584         if (m_backgroundBrush.GetStipple()->GetPixmap())
1585         {
1586             XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillTiled );
1587             XSetTile( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetPixmap() );
1588         }
1589         else
1590         {
1591             XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1592 //            XSetStipple( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetBitmap() );
1593         }
1594     }
1595
1596     if (IS_HATCH(m_backgroundBrush.GetStyle()))
1597     {
1598         XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1599         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1600         XSetStipple( (Display*) m_display, (GC) m_bgGC, hatches[num] );
1601     }
1602 }
1603
1604 void wxWindowDC::SetLogicalFunction( int function )
1605 {
1606     wxCHECK_RET( Ok(), "invalid dc" );
1607
1608     int x_function;
1609
1610     if (m_logicalFunction == function)
1611         return;
1612
1613     // VZ: shouldn't this be a CHECK?
1614     if (!m_window)
1615         return;
1616
1617     switch (function)
1618     {
1619     case wxCLEAR:
1620         x_function = GXclear;
1621         break;
1622     case wxXOR:
1623         x_function = GXxor;
1624         break;
1625     case wxINVERT:
1626         x_function = GXinvert;
1627         break;
1628     case wxOR_REVERSE:
1629         x_function = GXorReverse;
1630         break;
1631     case wxAND_REVERSE:
1632         x_function = GXandReverse;
1633         break;
1634     case wxAND:
1635         x_function = GXand;
1636         break;
1637     case wxOR:
1638         x_function = GXor;
1639         break;
1640     case wxAND_INVERT:
1641         x_function = GXandInverted;
1642         break;
1643     case wxNO_OP:
1644         x_function = GXnoop;
1645         break;
1646     case wxNOR:
1647         x_function = GXnor;
1648         break;
1649     case wxEQUIV:
1650         x_function = GXequiv;
1651         break;
1652     case wxSRC_INVERT:
1653         x_function = GXcopyInverted;
1654         break;
1655     case wxOR_INVERT:
1656         x_function = GXorInverted;
1657         break;
1658     case wxNAND:
1659         x_function = GXnand;
1660         break;
1661     case wxSET:
1662         x_function = GXset;
1663         break;
1664     case wxCOPY:
1665     default:
1666         x_function = GXcopy;
1667         break;
1668     }
1669
1670     XSetFunction( (Display*) m_display, (GC) m_penGC, x_function );
1671     XSetFunction( (Display*) m_display, (GC) m_brushGC, x_function );
1672
1673     // to stay compatible with wxMSW, we don't apply ROPs to the text
1674     // operations (i.e. DrawText/DrawRotatedText).
1675     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
1676     XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
1677
1678     m_logicalFunction = function;
1679 }
1680
1681 void wxWindowDC::SetTextForeground( const wxColour &col )
1682 {
1683     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1684
1685     // don't set m_textForegroundColour to an invalid colour as we'd crash
1686     // later then (we use m_textForegroundColour.GetColor() without checking
1687     // in a few places)
1688     if ( !col.Ok() || (m_textForegroundColour == col) )
1689         return;
1690
1691     m_textForegroundColour = col;
1692
1693     if (m_window)
1694     {
1695         m_textForegroundColour.CalcPixel( m_cmap );
1696         XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
1697     }
1698 }
1699
1700 void wxWindowDC::SetTextBackground( const wxColour &col )
1701 {
1702     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1703
1704     // same as above
1705     if ( !col.Ok() || (m_textBackgroundColour == col) )
1706         return;
1707
1708     m_textBackgroundColour = col;
1709
1710     if (m_window)
1711     {
1712         m_textBackgroundColour.CalcPixel( m_cmap );
1713         XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
1714     }
1715 }
1716
1717 void wxWindowDC::SetBackgroundMode( int mode )
1718 {
1719     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1720
1721     m_backgroundMode = mode;
1722
1723     if (!m_window) return;
1724
1725     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1726     // transparent/solid background mode
1727
1728     if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1729     {
1730         XSetFillStyle( (Display*) m_display, (GC) m_brushGC,
1731           (m_backgroundMode == wxTRANSPARENT) ? FillStippled : FillOpaqueStippled );
1732     }
1733 }
1734
1735 void wxWindowDC::SetPalette( const wxPalette& palette )
1736 {
1737 #if 0
1738     if (m_window)
1739     {
1740         if (palette.Ok())
1741             /* Use GetXColormap */
1742             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1743             (Colormap) palette.GetXColormap());
1744         else
1745             /* Use wxGetMainColormap */
1746             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1747             (Colormap) wxTheApp->GetMainColormap(m_display));
1748     }
1749 #endif
1750 }
1751
1752 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1753 {
1754     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1755
1756     if (!m_window) return;
1757
1758     wxRect rect;
1759     rect.x = XLOG2DEV(x);
1760     rect.y = YLOG2DEV(y);
1761     rect.width = XLOG2DEVREL(width);
1762     rect.height = YLOG2DEVREL(height);
1763
1764     if (!m_currentClippingRegion.IsNull())
1765         m_currentClippingRegion.Intersect( rect );
1766     else
1767         m_currentClippingRegion.Union( rect );
1768
1769 #if USE_PAINT_REGION
1770     if (!m_paintClippingRegion.IsNull())
1771         m_currentClippingRegion.Intersect( m_paintClippingRegion );
1772 #endif
1773
1774     wxCoord xx, yy, ww, hh;
1775     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1776     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1777
1778     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1779     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1780     XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1781     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1782 }
1783
1784 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
1785 {
1786     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1787
1788     if (region.Empty())
1789     {
1790         DestroyClippingRegion();
1791         return;
1792     }
1793
1794     if (!m_window) return;
1795
1796     if (!m_currentClippingRegion.IsNull())
1797         m_currentClippingRegion.Intersect( region );
1798     else
1799         m_currentClippingRegion.Union( region );
1800
1801 #if USE_PAINT_REGION
1802     if (!m_paintClippingRegion.IsNull())
1803         m_currentClippingRegion.Intersect( m_paintClippingRegion );
1804 #endif
1805
1806     wxCoord xx, yy, ww, hh;
1807     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1808     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1809
1810     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1811     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1812     XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1813     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1814 }
1815
1816 void wxWindowDC::DestroyClippingRegion()
1817 {
1818     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1819
1820     wxDC::DestroyClippingRegion();
1821
1822     m_currentClippingRegion.Clear();
1823
1824 #if USE_PAINT_REGION
1825     if (!m_paintClippingRegion.IsEmpty())
1826         m_currentClippingRegion.Union( m_paintClippingRegion );
1827 #endif
1828
1829     if (!m_window) return;
1830
1831     if (m_currentClippingRegion.IsEmpty())
1832     {
1833         XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
1834         XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
1835         XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
1836         XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
1837     }
1838     else
1839     {
1840         XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1841         XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1842         XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1843         XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1844     }
1845 }
1846
1847 void wxWindowDC::Destroy()
1848 {
1849     if (m_penGC) wxFreePoolGC( (GC) m_penGC );
1850     m_penGC = NULL;
1851     if (m_brushGC) wxFreePoolGC( (GC) m_brushGC );
1852     m_brushGC = NULL;
1853     if (m_textGC) wxFreePoolGC( (GC) m_textGC );
1854     m_textGC = NULL;
1855     if (m_bgGC) wxFreePoolGC( (GC) m_bgGC );
1856     m_bgGC = NULL;
1857 }
1858
1859 void wxWindowDC::ComputeScaleAndOrigin()
1860 {
1861     /* CMB: copy scale to see if it changes */
1862     double origScaleX = m_scaleX;
1863     double origScaleY = m_scaleY;
1864
1865     wxDC::ComputeScaleAndOrigin();
1866
1867     /* CMB: if scale has changed call SetPen to recalulate the line width */
1868     if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1869         (m_pen.Ok()))
1870     {
1871       /* this is a bit artificial, but we need to force wxDC to think
1872          the pen has changed */
1873       wxPen pen = m_pen;
1874       m_pen = wxNullPen;
1875       SetPen( pen );
1876   }
1877 }
1878
1879 wxSize wxWindowDC::GetPPI() const
1880 {
1881     return wxSize(100, 100);
1882 }
1883
1884 int wxWindowDC::GetDepth() const
1885 {
1886     wxFAIL_MSG(wxT("not implemented"));
1887
1888     return -1;
1889 }
1890
1891 // ----------------------------------------------------------------------------
1892 // wxPaintDC
1893 // ----------------------------------------------------------------------------
1894
1895 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
1896
1897 wxPaintDC::wxPaintDC(wxWindow* win)
1898   : wxClientDC(win)
1899 {
1900 #if USE_PAINT_REGION
1901     if (!win->GetClipPaintRegion())
1902         return;
1903
1904     m_paintClippingRegion = win->GetUpdateRegion();
1905     Region region = (Region) m_paintClippingRegion.GetX11Region();
1906     if (region)
1907     {
1908         m_paintClippingRegion = win->GetUpdateRegion();
1909         Region region2 = (Region) m_paintClippingRegion.GetX11Region();
1910         if (region2)
1911         {
1912             m_currentClippingRegion.Union( m_paintClippingRegion );
1913
1914             XSetRegion( (Display*) m_display, (GC) m_penGC, region2 );
1915             XSetRegion( (Display*) m_display, (GC) m_brushGC, region2 );
1916             XSetRegion( (Display*) m_display, (GC) m_textGC, region2 );
1917             XSetRegion( (Display*) m_display, (GC) m_bgGC, region2 );
1918         }
1919     }
1920 #endif // USE_PAINT_REGION
1921 }
1922
1923 //-----------------------------------------------------------------------------
1924 // wxClientDC
1925 //-----------------------------------------------------------------------------
1926
1927 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
1928
1929 wxClientDC::wxClientDC( wxWindow *win )
1930           : wxWindowDC( win )
1931 {
1932     wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
1933 }
1934
1935 void wxClientDC::DoGetSize(int *width, int *height) const
1936 {
1937     wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
1938
1939     m_owner->GetClientSize( width, height );
1940 }
1941
1942 // ----------------------------------------------------------------------------
1943 // wxDCModule
1944 // ----------------------------------------------------------------------------
1945
1946 class wxDCModule : public wxModule
1947 {
1948 public:
1949     bool OnInit();
1950     void OnExit();
1951
1952 private:
1953     DECLARE_DYNAMIC_CLASS(wxDCModule)
1954 };
1955
1956 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
1957
1958 bool wxDCModule::OnInit()
1959 {
1960     wxInitGCPool();
1961     return TRUE;
1962 }
1963
1964 void wxDCModule::OnExit()
1965 {
1966     wxCleanUpGCPool();
1967 }