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