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     else
 229     if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
 230     {
 231         m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_MONO );
 232         m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_MONO );
 233         m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_MONO );
 234         m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_MONO );
 235     }
 236     else
 237     {
 238         m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_COLOUR );
 239         m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_COLOUR );
 240         m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_COLOUR );
 241         m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_COLOUR );
 242     }
 243
 244     /* background colour */
 245     m_backgroundBrush = *wxWHITE_BRUSH;
 246     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
 247     unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
 248
 249     /* m_textGC */
 250     m_textForegroundColour.CalcPixel( m_cmap );
 251     XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
 252
 253     m_textBackgroundColour.CalcPixel( m_cmap );
 254     XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
 255
 256     XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillSolid );
 257
 258     /* m_penGC */
 259     m_pen.GetColour().CalcPixel( m_cmap );
 260     XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
 261     XSetBackground( (Display*) m_display, (GC) m_penGC, bg_col );
 262
 263     XSetLineAttributes( (Display*) m_display, (GC) m_penGC, 0, LineSolid, CapNotLast, JoinRound );
 264
 265     /* m_brushGC */
 266     m_brush.GetColour().CalcPixel( m_cmap );
 267     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
 268     XSetBackground( (Display*) m_display, (GC) m_brushGC, bg_col );
 269
 270     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
 271
 272     /* m_bgGC */
 273     XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
 274     XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );
 275
 276     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 277
 278     /* ROPs */
 279     XSetFunction( (Display*) m_display, (GC) m_textGC, GXcopy );
 280     XSetFunction( (Display*) m_display, (GC) m_brushGC, GXcopy );
 281     XSetFunction( (Display*) m_display, (GC)m_penGC, GXcopy );
 282
 283     /* clipping */
 284     XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
 285     XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
 286     XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
 287     XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
 288
 289     if (!hatch_bitmap)
 290     {
 291         int xscreen = DefaultScreen( (Display*) m_display );
 292         Window xroot = RootWindow( (Display*) m_display, xscreen );
 293
 294         hatch_bitmap    = hatches;
 295         hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
 296         hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );
 297         hatch_bitmap[2] = XCreateBitmapFromData( (Display*) m_display, xroot, fdiag_bits, fdiag_width, fdiag_height );
 298         hatch_bitmap[3] = XCreateBitmapFromData( (Display*) m_display, xroot, cross_bits, cross_width, cross_height );
 299         hatch_bitmap[4] = XCreateBitmapFromData( (Display*) m_display, xroot, horiz_bits, horiz_width, horiz_height );
 300         hatch_bitmap[5] = XCreateBitmapFromData( (Display*) m_display, xroot, verti_bits, verti_width, verti_height );
 301     }
 302 }
 303
 304 void wxWindowDC::DoGetSize( int* width, int* height ) const
 305 {
 306     wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
 307
 308     m_owner->GetSize(width, height);
 309 }
 310
 311 void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
 312                            const wxColour& WXUNUSED(col), int WXUNUSED(style) )
 313 {
 314     wxFAIL_MSG("not implemented");
 315 }
 316
 317 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 318 {
 319     // Generic (and therefore rather inefficient) method.
 320     // Could be improved.
 321     wxMemoryDC memdc;
 322     wxBitmap bitmap(1, 1);
 323     memdc.SelectObject(bitmap);
 324     memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
 325     memdc.SelectObject(wxNullBitmap);
 326     wxImage image(bitmap);
 327     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
 328     return TRUE;
 329 }
 330
 331 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 332 {
 333     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 334
 335     if (m_pen.GetStyle() != wxTRANSPARENT)
 336     {
 337         if (m_window)
 338             XDrawLine( (Display*) m_display, (Window) m_window,
 339                 (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
 340
 341         CalcBoundingBox(x1, y1);
 342         CalcBoundingBox(x2, y2);
 343     }
 344 }
 345
 346 void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
 347 {
 348     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 349
 350     if (m_pen.GetStyle() != wxTRANSPARENT)
 351     {
 352         int w = 0;
 353         int h = 0;
 354         GetSize( &w, &h );
 355         wxCoord xx = XLOG2DEV(x);
 356         wxCoord yy = YLOG2DEV(y);
 357         if (m_window)
 358         {
 359             XDrawLine( (Display*) m_display, (Window) m_window,
 360                 (GC) m_penGC, 0, yy, XLOG2DEVREL(w), yy );
 361             XDrawLine( (Display*) m_display, (Window) m_window,
 362                 (GC) m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
 363         }
 364     }
 365 }
 366
 367 void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
 368 {
 369     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 370
 371     wxCoord xx1 = XLOG2DEV(x1);
 372     wxCoord yy1 = YLOG2DEV(y1);
 373     wxCoord xx2 = XLOG2DEV(x2);
 374     wxCoord yy2 = YLOG2DEV(y2);
 375     wxCoord xxc = XLOG2DEV(xc);
 376     wxCoord yyc = YLOG2DEV(yc);
 377     double dx = xx1 - xxc;
 378     double dy = yy1 - yyc;
 379     double radius = sqrt((double)(dx*dx+dy*dy));
 380     wxCoord   r      = (wxCoord)radius;
 381     double radius1, radius2;
 382
 383     if (xx1 == xx2 && yy1 == yy2)
 384     {
 385         radius1 = 0.0;
 386         radius2 = 360.0;
 387     }
 388     else
 389     if (radius == 0.0)
 390     {
 391         radius1 = radius2 = 0.0;
 392     }
 393     else
 394     {
 395         radius1 = (xx1 - xxc == 0) ?
 396             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 397             -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
 398         radius2 = (xx2 - xxc == 0) ?
 399             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 400             -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
 401     }
 402     wxCoord alpha1 = wxCoord(radius1 * 64.0);
 403     wxCoord alpha2 = wxCoord((radius2 - radius1) * 64.0);
 404     while (alpha2 <= 0) alpha2 += 360*64;
 405     while (alpha1 > 360*64) alpha1 -= 360*64;
 406
 407     if (m_window)
 408     {
 409         if (m_brush.GetStyle() != wxTRANSPARENT)
 410         {
 411             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 412             {
 413                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 414                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 415                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 416
 417                 XFillArc( (Display*) m_display, (Window) m_window,
 418                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 419
 420                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 421             } else
 422             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 423             {
 424                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 425                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 426
 427                 XFillArc( (Display*) m_display, (Window) m_window,
 428                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 429
 430                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 431             } else
 432             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 433             {
 434                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 435                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 436
 437                 XFillArc( (Display*) m_display, (Window) m_window,
 438                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 439
 440                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 441             } else
 442             if (m_brush.GetStyle() == wxSTIPPLE)
 443             {
 444                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 445                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 446                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 447
 448                 XFillArc( (Display*) m_display, (Window) m_window,
 449                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 450
 451                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 452             }
 453             else
 454             {
 455                 XFillArc( (Display*) m_display, (Window) m_window,
 456                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 457             }
 458         }
 459
 460         if (m_pen.GetStyle() != wxTRANSPARENT)
 461         {
 462             XDrawArc( (Display*) m_display, (Window) m_window,
 463                (GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 464
 465             XDrawLine( (Display*) m_display, (Window) m_window,
 466                (GC) m_penGC, xx1, yy1, xxc, yyc );
 467
 468             XDrawLine( (Display*) m_display, (Window) m_window,
 469                (GC) m_penGC, xxc, yyc, xx2, yy2 );
 470         }
 471     }
 472
 473     CalcBoundingBox (x1, y1);
 474     CalcBoundingBox (x2, y2);
 475 }
 476
 477 void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
 478 {
 479     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 480
 481     wxCoord xx = XLOG2DEV(x);
 482     wxCoord yy = YLOG2DEV(y);
 483     wxCoord ww = m_signX * XLOG2DEVREL(width);
 484     wxCoord hh = m_signY * YLOG2DEVREL(height);
 485
 486     // CMB: handle -ve width and/or height
 487     if (ww < 0) { ww = -ww; xx = xx - ww; }
 488     if (hh < 0) { hh = -hh; yy = yy - hh; }
 489
 490     if (m_window)
 491     {
 492         wxCoord start = wxCoord(sa * 64.0);
 493         wxCoord end = wxCoord((ea-sa) * 64.0);
 494
 495         if (m_brush.GetStyle() != wxTRANSPARENT)
 496         {
 497             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 498             {
 499                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 500                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 501                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 502
 503                 XFillArc( (Display*) m_display, (Window) m_window,
 504                     (GC) m_textGC, xx, yy, ww, hh, start, end );
 505
 506                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 507             } else
 508             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 509             {
 510                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 511                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 512
 513                 XFillArc( (Display*) m_display, (Window) m_window,
 514                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 515
 516                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 517             } else
 518             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 519             {
 520                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 521                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 522
 523                 XFillArc( (Display*) m_display, (Window) m_window,
 524                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 525
 526                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 527             } else
 528             if (m_brush.GetStyle() == wxSTIPPLE)
 529             {
 530                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 531                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 532                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 533
 534                 XFillArc( (Display*) m_display, (Window) m_window,
 535                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 536
 537                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 538             }
 539             else
 540             {
 541                 XFillArc( (Display*) m_display, (Window) m_window,
 542                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
 543             }
 544         }
 545
 546         if (m_pen.GetStyle() != wxTRANSPARENT)
 547         {
 548             XDrawArc( (Display*) m_display, (Window) m_window,
 549                 (GC) m_penGC, xx, yy, ww, hh, start, end );
 550         }
 551     }
 552
 553     CalcBoundingBox (x, y);
 554     CalcBoundingBox (x + width, y + height);
 555 }
 556
 557 void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
 558 {
 559     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 560
 561     if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
 562         XDrawPoint( (Display*) m_display, (Window) m_window,
 563                 (GC) m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 564
 565     CalcBoundingBox (x, y);
 566 }
 567
 568 void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
 569 {
 570     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 571
 572     if (m_pen.GetStyle() == wxTRANSPARENT) return;
 573     if (n <= 0) return;
 574
 575     XPoint *xpoints = new XPoint[n];
 576     for (int i = 0; i < n; i++)
 577     {
 578         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
 579         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
 580
 581         CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
 582     }
 583     XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n, 0 );
 584
 585     delete[] xpoints;
 586 }
 587
 588 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
 589                                 wxCoord xoffset, wxCoord yoffset, int fillStyle )
 590 {
 591     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 592
 593     if (n <= 0) return;
 594
 595     XPoint *xpoints = new XPoint[n + 1];
 596     int i;
 597     for (i = 0; i < n; i++)
 598     {
 599         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
 600         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
 601
 602         CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
 603     }
 604
 605     if (m_window)
 606     {
 607         if (m_brush.GetStyle() != wxTRANSPARENT)
 608         {
 609
 610             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 611             {
 612                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 613                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 614                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 615
 616                 XFillPolygon( (Display*) m_display, (Window) m_window,
 617                     (GC) m_textGC, xpoints, n, Complex, 0);
 618
 619                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 620             } else
 621             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 622             {
 623                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 624                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 625
 626                 XFillPolygon( (Display*) m_display, (Window) m_window,
 627                     (GC) m_brushGC, xpoints, n, Complex, 0);
 628
 629                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 630             } else
 631             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 632             {
 633                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 634                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 635
 636                 XFillPolygon( (Display*) m_display, (Window) m_window,
 637                     (GC) m_brushGC, xpoints, n, Complex, 0);
 638
 639                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 640             } else
 641             if (m_brush.GetStyle() == wxSTIPPLE)
 642             {
 643                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 644                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 645                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 646
 647                 XFillPolygon( (Display*) m_display, (Window) m_window,
 648                     (GC) m_brushGC, xpoints, n, Complex, 0);
 649
 650                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 651             }
 652             else
 653             {
 654                 XFillPolygon( (Display*) m_display, (Window) m_window,
 655                     (GC) m_brushGC, xpoints, n, Complex, 0);
 656             }
 657         }
 658
 659         if (m_pen.GetStyle () != wxTRANSPARENT)
 660         {
 661             // Close figure for XDrawLines
 662             xpoints[i].x = xpoints[0].x;
 663             xpoints[i].y = xpoints[0].y;
 664
 665             XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n + 1, 0);
 666         }
 667     }
 668
 669     delete[] xpoints;
 670 }
 671
 672 void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 673 {
 674     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 675
 676     wxCoord xx = XLOG2DEV(x);
 677     wxCoord yy = YLOG2DEV(y);
 678     wxCoord ww = m_signX * XLOG2DEVREL(width);
 679     wxCoord hh = m_signY * YLOG2DEVREL(height);
 680
 681     // CMB: draw nothing if transformed w or h is 0
 682     if (ww == 0 || hh == 0) return;
 683
 684     // CMB: handle -ve width and/or height
 685     if (ww < 0) { ww = -ww; xx = xx - ww; }
 686     if (hh < 0) { hh = -hh; yy = yy - hh; }
 687
 688     if (m_window)
 689     {
 690         if (m_brush.GetStyle() != wxTRANSPARENT)
 691         {
 692             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 693             {
 694                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 695                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 696                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 697
 698                 XFillRectangle( (Display*) m_display, (Window) m_window,
 699                     (GC) m_textGC, xx, yy, ww, hh );
 700
 701                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 702             } else
 703             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 704             {
 705                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 706                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 707
 708                 XFillRectangle( (Display*) m_display, (Window) m_window,
 709                     (GC) m_brushGC, xx, yy, ww, hh );
 710
 711                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 712             } else
 713             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 714             {
 715                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 716                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 717
 718                 XFillRectangle( (Display*) m_display, (Window) m_window,
 719                     (GC) m_brushGC, xx, yy, ww, hh );
 720
 721                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 722             } else
 723             if (m_brush.GetStyle() == wxSTIPPLE)
 724             {
 725                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 726                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 727                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 728
 729                 XFillRectangle( (Display*) m_display, (Window) m_window,
 730                     (GC) m_brushGC, xx, yy, ww, hh );
 731
 732                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 733             }
 734             else
 735             {
 736                 XFillRectangle( (Display*) m_display, (Window) m_window,
 737                     (GC) m_brushGC, xx, yy, ww, hh );
 738             }
 739         }
 740
 741         if (m_pen.GetStyle () != wxTRANSPARENT)
 742         {
 743             XDrawRectangle( (Display*) m_display, (Window) m_window,
 744                 (GC) m_penGC, xx, yy, ww-1, hh-1 );
 745         }
 746     }
 747
 748     CalcBoundingBox( x, y );
 749     CalcBoundingBox( x + width, y + height );
 750 }
 751
 752 void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
 753 {
 754    // later
 755 }
 756
 757 void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 758 {
 759     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 760
 761     wxCoord xx = XLOG2DEV(x);
 762     wxCoord yy = YLOG2DEV(y);
 763     wxCoord ww = m_signX * XLOG2DEVREL(width);
 764     wxCoord hh = m_signY * YLOG2DEVREL(height);
 765
 766     // CMB: handle -ve width and/or height
 767     if (ww < 0) { ww = -ww; xx = xx - ww; }
 768     if (hh < 0) { hh = -hh; yy = yy - hh; }
 769
 770     if (m_window)
 771     {
 772         if (m_brush.GetStyle() != wxTRANSPARENT)
 773         {
 774             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 775             {
 776                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
 777                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 778                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 779
 780                 XFillArc( (Display*) m_display, (Window) m_window,
 781                     (GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );
 782
 783                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 784             } else
 785             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
 786             {
 787                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 788                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
 789
 790                 XFillArc( (Display*) m_display, (Window) m_window,
 791                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 792
 793                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 794             } else
 795             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
 796             {
 797                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 798                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
 799
 800                 XFillArc( (Display*) m_display, (Window) m_window,
 801                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 802
 803                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 804             } else
 805             if (m_brush.GetStyle() == wxSTIPPLE)
 806             {
 807                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
 808                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 809                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 810
 811                 XFillArc( (Display*) m_display, (Window) m_window,
 812                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 813
 814                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
 815             }
 816             else
 817             {
 818                 XFillArc( (Display*) m_display, (Window) m_window,
 819                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
 820             }
 821         }
 822
 823         if (m_pen.GetStyle () != wxTRANSPARENT)
 824         {
 825             XDrawArc( (Display*) m_display, (Window) m_window,
 826                 (GC) m_penGC, xx, yy, ww, hh, 0, 360*64 );
 827         }
 828     }
 829
 830     CalcBoundingBox( x, y );
 831     CalcBoundingBox( x + width, y + height );
 832 }
 833
 834 void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
 835 {
 836 }
 837
 838 void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
 839                                wxCoord x, wxCoord y,
 840                                bool useMask )
 841 {
 842     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 843
 844     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
 845
 846     bool is_mono = (bitmap.GetBitmap() != NULL);
 847
 848     /* scale/translate size and position */
 849     int xx = XLOG2DEV(x);
 850     int yy = YLOG2DEV(y);
 851
 852     int w = bitmap.GetWidth();
 853     int h = bitmap.GetHeight();
 854
 855     CalcBoundingBox( x, y );
 856     CalcBoundingBox( x + w, y + h );
 857
 858     if (!m_window) return;
 859
 860     int ww = XLOG2DEVREL(w);
 861     int hh = YLOG2DEVREL(h);
 862
 863     /* compare to current clipping region */
 864     if (!m_currentClippingRegion.IsNull())
 865     {
 866         wxRegion tmp( xx,yy,ww,hh );
 867         tmp.Intersect( m_currentClippingRegion );
 868         if (tmp.IsEmpty())
 869             return;
 870     }
 871
 872     /* scale bitmap if required */
 873     wxBitmap use_bitmap;
 874     if ((w != ww) || (h != hh))
 875     {
 876         wxImage image( bitmap );
 877         image.Rescale( ww, hh );
 878 #if 0
 879         if (is_mono)
 880             use_bitmap = image.ConvertToMonoBitmap(255,255,255);
 881         else
 882 #endif
 883             use_bitmap = image.ConvertToBitmap();
 884     }
 885     else
 886     {
 887         use_bitmap = bitmap;
 888     }
 889
 890     /* apply mask if any */
 891     WXPixmap mask = NULL;
 892     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
 893     {
 894         if (useMask && mask)
 895         {
 896             WXPixmap new_mask = NULL;
 897 #if 0
 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 #endif
 918             if (is_mono)
 919             {
 920                 if (new_mask)
 921                     XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) new_mask );
 922                 else
 923                     XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) mask );
 924                 XSetClipOrigin( (Display*) m_display, (GC) m_textGC, xx, yy );
 925             }
 926             else
 927             {
 928                 if (new_mask)
 929                     XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) new_mask );
 930                 else
 931                     XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
 932                 XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
 933             }
 934
 935             if (new_mask)
 936                XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
 937         }
 938     }
 939
 940     /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
 941        drawing a mono-bitmap (XBitmap) we use the current text GC */
 942     if (is_mono)
 943         XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
 944             (GC) m_textGC, 0, 0, w, h, xx, yy, 1 );
 945     else
 946         XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
 947             (GC) m_penGC, 0, 0, w, h, xx, yy );
 948
 949     /* remove mask again if any */
 950     if (useMask && mask)
 951     {
 952         if (is_mono)
 953         {
 954             XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
 955             XSetClipOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
 956             if (!m_currentClippingRegion.IsNull())
 957                 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
 958         }
 959         else
 960         {
 961             XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
 962             XSetClipOrigin( (Display*) m_display, (GC) m_penGC, 0, 0 );
 963             if (!m_currentClippingRegion.IsNull())
 964                 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
 965         }
 966     }
 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 #if 0
1236     wxCoord width = gdk_string_width( font, text.mbc_str() );
1237     wxCoord height = font->ascent + font->descent;
1238
1239     if ( m_backgroundMode == wxSOLID )
1240     {
1241         gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
1242         gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
1243         gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1244     }
1245 #endif
1246
1247     XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
1248 #if !wxUSE_NANOX
1249     if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
1250 #endif
1251     {
1252         XDrawString( (Display*) m_display, (Window) m_window,
1253             (GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.Len() );
1254     }
1255
1256 #if 0
1257     if (m_font.GetUnderlined())
1258     {
1259         wxCoord ul_y = y + XFontStructGetAscent(font);
1260         if (font->descent > 0) ul_y++;
1261         gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
1262     }
1263
1264     width = wxCoord(width / m_scaleX);
1265     height = wxCoord(height / m_scaleY);
1266
1267     CalcBoundingBox (x + width, y + height);
1268     CalcBoundingBox (x, y);
1269 #endif
1270 }
1271
1272 void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1273 {
1274     // later
1275 }
1276
1277 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
1278                                 wxCoord *descent, wxCoord *externalLeading,
1279                                 wxFont *font ) const
1280 {
1281     wxCHECK_RET( Ok(), "invalid dc" );
1282
1283     wxFont fontToUse = m_font;
1284     if (font) fontToUse = *font;
1285
1286     wxCHECK_RET( fontToUse.Ok(), "invalid font" );
1287
1288     XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
1289
1290     wxCHECK_RET( xfont, wxT("invalid font") );
1291
1292     int direction, ascent, descent2;
1293     XCharStruct overall;
1294
1295     XTextExtents( xfont, (char*) string.c_str(), string.Len(), &direction,
1296         &ascent, &descent2, &overall);
1297
1298     if (width)
1299         *width = (wxCoord)( overall.width / m_scaleX );
1300     if (height)
1301         *height = (wxCoord)((ascent + descent2) / m_scaleY );
1302     if (descent)
1303         *descent = (wxCoord)(descent2 / m_scaleY );
1304     if (externalLeading)
1305         *externalLeading = 0; // ??
1306 }
1307
1308 wxCoord wxWindowDC::GetCharWidth() const
1309 {
1310     wxCHECK_MSG( Ok(), 0, "invalid dc" );
1311
1312     wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1313
1314     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1315
1316     wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1317
1318     int direction, ascent, descent;
1319     XCharStruct overall;
1320
1321     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1322
1323     return (wxCoord)(overall.width / m_scaleX);
1324 }
1325
1326 wxCoord wxWindowDC::GetCharHeight() const
1327 {
1328     wxCHECK_MSG( Ok(), 0, "invalid dc" );
1329
1330     wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1331
1332     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1333
1334     wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1335
1336     int direction, ascent, descent;
1337     XCharStruct overall;
1338
1339     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1340
1341     return (wxCoord)((ascent+descent) / m_scaleY);
1342 }
1343
1344 void wxWindowDC::Clear()
1345 {
1346     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1347
1348     if (!m_window) return;
1349
1350     /* - we either are a memory dc or have a window as the
1351        owner. anything else shouldn't happen.
1352        - we don't use gdk_window_clear() as we don't set
1353        the window's background colour anymore. it is too
1354        much pain to keep the DC's and the window's back-
1355        ground colour in synch. */
1356
1357     if (m_owner)
1358     {
1359         int width,height;
1360         m_owner->GetSize( &width, &height );
1361         XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1362         return;
1363     }
1364
1365     if (m_isMemDC)
1366     {
1367         int width,height;
1368         GetSize( &width, &height );
1369         XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1370         return;
1371     }
1372 }
1373
1374 void wxWindowDC::SetFont( const wxFont &font )
1375 {
1376     wxCHECK_RET( Ok(), "invalid dc" );
1377
1378     m_font = font;
1379 }
1380
1381 void wxWindowDC::SetPen( const wxPen &pen )
1382 {
1383     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1384
1385     if (m_pen == pen) return;
1386
1387     m_pen = pen;
1388
1389     if (!m_pen.Ok()) return;
1390
1391     if (!m_window) return;
1392
1393     int width = m_pen.GetWidth();
1394     if (width <= 0)
1395     {
1396         // CMB: if width is non-zero scale it with the dc
1397         width = 1;
1398     }
1399     else
1400     {
1401         // X doesn't allow different width in x and y and so we take
1402         // the average
1403         double w = 0.5 +
1404                    ( fabs((double) XLOG2DEVREL(width)) +
1405                      fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1406         width = (int)w;
1407     }
1408
1409     static const wxX11Dash dotted[] = {1, 1};
1410     static const wxX11Dash short_dashed[] = {2, 2};
1411     static const wxX11Dash long_dashed[] = {2, 4};
1412     static const wxX11Dash dotted_dashed[] = {3, 3, 1, 3};
1413
1414     // We express dash pattern in pen width unit, so we are
1415     // independent of zoom factor and so on...
1416     int req_nb_dash;
1417     const wxX11Dash *req_dash;
1418
1419     int lineStyle = LineSolid;
1420     switch (m_pen.GetStyle())
1421     {
1422         case wxUSER_DASH:
1423         {
1424             lineStyle = LineOnOffDash;
1425             req_nb_dash = m_pen.GetDashCount();
1426             req_dash = (wxX11Dash*)m_pen.GetDash();
1427             break;
1428         }
1429         case wxDOT:
1430         {
1431             lineStyle = LineOnOffDash;
1432             req_nb_dash = 2;
1433             req_dash = dotted;
1434             break;
1435         }
1436         case wxLONG_DASH:
1437         {
1438             lineStyle = LineOnOffDash;
1439             req_nb_dash = 2;
1440             req_dash = long_dashed;
1441             break;
1442         }
1443         case wxSHORT_DASH:
1444         {
1445             lineStyle = LineOnOffDash;
1446             req_nb_dash = 2;
1447             req_dash = short_dashed;
1448             break;
1449         }
1450         case wxDOT_DASH:
1451         {
1452 //            lineStyle = LineDoubleDash;
1453             lineStyle = LineOnOffDash;
1454             req_nb_dash = 4;
1455             req_dash = dotted_dashed;
1456             break;
1457         }
1458
1459         case wxTRANSPARENT:
1460         case wxSTIPPLE_MASK_OPAQUE:
1461         case wxSTIPPLE:
1462         case wxSOLID:
1463         default:
1464         {
1465             lineStyle = LineSolid;
1466             req_dash = (wxX11Dash*)NULL;
1467             req_nb_dash = 0;
1468             break;
1469         }
1470     }
1471
1472     int capStyle = CapRound;
1473     switch (m_pen.GetCap())
1474     {
1475         case wxCAP_PROJECTING: { capStyle = CapProjecting; break; }
1476         case wxCAP_BUTT:       { capStyle = CapButt;       break; }
1477         case wxCAP_ROUND:
1478         default:
1479         {
1480             if (width <= 1)
1481             {
1482                 width = 0;
1483                 capStyle = CapNotLast;
1484             }
1485             else
1486             {
1487                 capStyle = CapRound;
1488             }
1489             break;
1490         }
1491     }
1492
1493     int joinStyle = JoinRound;
1494     switch (m_pen.GetJoin())
1495     {
1496         case wxJOIN_BEVEL: { joinStyle = JoinBevel; break; }
1497         case wxJOIN_MITER: { joinStyle = JoinMiter; break; }
1498         case wxJOIN_ROUND:
1499         default:           { joinStyle = JoinRound; break; }
1500     }
1501
1502     XSetLineAttributes( (Display*) m_display, (GC) m_penGC, width, lineStyle, capStyle, joinStyle );
1503
1504     m_pen.GetColour().CalcPixel( m_cmap );
1505     XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
1506 }
1507
1508 void wxWindowDC::SetBrush( const wxBrush &brush )
1509 {
1510     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1511
1512     if (m_brush == brush) return;
1513
1514     m_brush = brush;
1515
1516     if (!m_brush.Ok()) return;
1517
1518     if (!m_window) return;
1519
1520     m_brush.GetColour().CalcPixel( m_cmap );
1521     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
1522
1523     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
1524
1525     if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1526     {
1527         if (m_brush.GetStipple()->GetPixmap())
1528         {
1529             XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillTiled );
1530             XSetTile( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetPixmap() );
1531         }
1532         else
1533         {
1534             XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1535             XSetStipple( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetBitmap() );
1536         }
1537     }
1538
1539     if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1540     {
1541         XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillOpaqueStippled );
1542         XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
1543     }
1544
1545     if (IS_HATCH(m_brush.GetStyle()))
1546     {
1547         XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1548         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1549         XSetStipple( (Display*) m_display, (GC) m_brushGC, hatches[num] );
1550     }
1551 }
1552
1553 void wxWindowDC::SetBackground( const wxBrush &brush )
1554 {
1555    /* CMB 21/7/98: Added SetBackground. Sets background brush
1556     * for Clear() and bg colour for shapes filled with cross-hatch brush */
1557
1558     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1559
1560     if (m_backgroundBrush == brush) return;
1561
1562     m_backgroundBrush = brush;
1563
1564     if (!m_backgroundBrush.Ok()) return;
1565
1566     if (!m_window) return;
1567
1568     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1569     XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );
1570     XSetBackground( (Display*) m_display, (GC) m_penGC, m_backgroundBrush.GetColour().GetPixel() );
1571     XSetBackground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1572     XSetForeground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1573
1574     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
1575
1576     if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1577     {
1578         if (m_backgroundBrush.GetStipple()->GetPixmap())
1579         {
1580             XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillTiled );
1581             XSetTile( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetPixmap() );
1582         }
1583         else
1584         {
1585             XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1586             XSetStipple( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetBitmap() );
1587         }
1588     }
1589
1590     if (IS_HATCH(m_backgroundBrush.GetStyle()))
1591     {
1592         XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1593         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1594         XSetStipple( (Display*) m_display, (GC) m_bgGC, hatches[num] );
1595     }
1596 }
1597
1598 void wxWindowDC::SetLogicalFunction( int function )
1599 {
1600     wxCHECK_RET( Ok(), "invalid dc" );
1601
1602     int x_function;
1603
1604     if (m_logicalFunction == function)
1605         return;
1606
1607     // VZ: shouldn't this be a CHECK?
1608     if (!m_window)
1609         return;
1610
1611     switch (function)
1612     {
1613     case wxCLEAR:
1614         x_function = GXclear;
1615         break;
1616     case wxXOR:
1617         x_function = GXxor;
1618         break;
1619     case wxINVERT:
1620         x_function = GXinvert;
1621         break;
1622     case wxOR_REVERSE:
1623         x_function = GXorReverse;
1624         break;
1625     case wxAND_REVERSE:
1626         x_function = GXandReverse;
1627         break;
1628     case wxAND:
1629         x_function = GXand;
1630         break;
1631     case wxOR:
1632         x_function = GXor;
1633         break;
1634     case wxAND_INVERT:
1635         x_function = GXandInverted;
1636         break;
1637     case wxNO_OP:
1638         x_function = GXnoop;
1639         break;
1640     case wxNOR:
1641         x_function = GXnor;
1642         break;
1643     case wxEQUIV:
1644         x_function = GXequiv;
1645         break;
1646     case wxSRC_INVERT:
1647         x_function = GXcopyInverted;
1648         break;
1649     case wxOR_INVERT:
1650         x_function = GXorInverted;
1651         break;
1652     case wxNAND:
1653         x_function = GXnand;
1654         break;
1655     case wxSET:
1656         x_function = GXset;
1657         break;
1658     case wxCOPY:
1659     default:
1660         x_function = GXcopy;
1661         break;
1662     }
1663
1664     XSetFunction( (Display*) m_display, (GC) m_penGC, x_function );
1665     XSetFunction( (Display*) m_display, (GC) m_brushGC, x_function );
1666
1667     // to stay compatible with wxMSW, we don't apply ROPs to the text
1668     // operations (i.e. DrawText/DrawRotatedText).
1669     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
1670     XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
1671
1672     m_logicalFunction = function;
1673 }
1674
1675 void wxWindowDC::SetTextForeground( const wxColour &col )
1676 {
1677     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1678
1679     // don't set m_textForegroundColour to an invalid colour as we'd crash
1680     // later then (we use m_textForegroundColour.GetColor() without checking
1681     // in a few places)
1682     if ( !col.Ok() || (m_textForegroundColour == col) )
1683         return;
1684
1685     m_textForegroundColour = col;
1686
1687     if (m_window)
1688     {
1689         m_textForegroundColour.CalcPixel( m_cmap );
1690         XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
1691     }
1692 }
1693
1694 void wxWindowDC::SetTextBackground( const wxColour &col )
1695 {
1696     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1697
1698     // same as above
1699     if ( !col.Ok() || (m_textBackgroundColour == col) )
1700         return;
1701
1702     m_textBackgroundColour = col;
1703
1704     if (m_window)
1705     {
1706         m_textBackgroundColour.CalcPixel( m_cmap );
1707         XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
1708     }
1709 }
1710
1711 void wxWindowDC::SetBackgroundMode( int mode )
1712 {
1713     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1714
1715     m_backgroundMode = mode;
1716
1717     if (!m_window) return;
1718
1719     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1720     // transparent/solid background mode
1721
1722     if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1723     {
1724         XSetFillStyle( (Display*) m_display, (GC) m_brushGC,
1725           (m_backgroundMode == wxTRANSPARENT) ? FillStippled : FillOpaqueStippled );
1726     }
1727 }
1728
1729 void wxWindowDC::SetPalette( const wxPalette& palette )
1730 {
1731 #if 0
1732     if (m_window)
1733     {
1734         if (palette.Ok())
1735             /* Use GetXColormap */
1736             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1737             (Colormap) palette.GetXColormap());
1738         else
1739             /* Use wxGetMainColormap */
1740             XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1741             (Colormap) wxTheApp->GetMainColormap(m_display));
1742     }
1743 #endif
1744 }
1745
1746 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1747 {
1748     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1749
1750     if (!m_window) return;
1751
1752     wxRect rect;
1753     rect.x = XLOG2DEV(x);
1754     rect.y = YLOG2DEV(y);
1755     rect.width = XLOG2DEVREL(width);
1756     rect.height = YLOG2DEVREL(height);
1757
1758     if (!m_currentClippingRegion.IsNull())
1759         m_currentClippingRegion.Intersect( rect );
1760     else
1761         m_currentClippingRegion.Union( rect );
1762
1763 #if USE_PAINT_REGION
1764     if (!m_paintClippingRegion.IsNull())
1765         m_currentClippingRegion.Intersect( m_paintClippingRegion );
1766 #endif
1767
1768     wxCoord xx, yy, ww, hh;
1769     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1770     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1771
1772     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1773     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1774     XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1775     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1776 }
1777
1778 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
1779 {
1780     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1781
1782     if (region.Empty())
1783     {
1784         DestroyClippingRegion();
1785         return;
1786     }
1787
1788     if (!m_window) return;
1789
1790     if (!m_currentClippingRegion.IsNull())
1791         m_currentClippingRegion.Intersect( region );
1792     else
1793         m_currentClippingRegion.Union( region );
1794
1795 #if USE_PAINT_REGION
1796     if (!m_paintClippingRegion.IsNull())
1797         m_currentClippingRegion.Intersect( m_paintClippingRegion );
1798 #endif
1799
1800     wxCoord xx, yy, ww, hh;
1801     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1802     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1803
1804     XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1805     XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1806     XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1807     XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1808 }
1809
1810 void wxWindowDC::DestroyClippingRegion()
1811 {
1812     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1813
1814     wxDC::DestroyClippingRegion();
1815
1816     m_currentClippingRegion.Clear();
1817
1818 #if USE_PAINT_REGION
1819     if (!m_paintClippingRegion.IsEmpty())
1820         m_currentClippingRegion.Union( m_paintClippingRegion );
1821 #endif
1822
1823     if (!m_window) return;
1824
1825     if (m_currentClippingRegion.IsEmpty())
1826     {
1827         XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
1828         XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
1829         XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
1830         XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
1831     }
1832     else
1833     {
1834         XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1835         XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1836         XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1837         XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1838     }
1839 }
1840
1841 void wxWindowDC::Destroy()
1842 {
1843     if (m_penGC) wxFreePoolGC( (GC) m_penGC );
1844     m_penGC = NULL;
1845     if (m_brushGC) wxFreePoolGC( (GC) m_brushGC );
1846     m_brushGC = NULL;
1847     if (m_textGC) wxFreePoolGC( (GC) m_textGC );
1848     m_textGC = NULL;
1849     if (m_bgGC) wxFreePoolGC( (GC) m_bgGC );
1850     m_bgGC = NULL;
1851 }
1852
1853 void wxWindowDC::ComputeScaleAndOrigin()
1854 {
1855     /* CMB: copy scale to see if it changes */
1856     double origScaleX = m_scaleX;
1857     double origScaleY = m_scaleY;
1858
1859     wxDC::ComputeScaleAndOrigin();
1860
1861     /* CMB: if scale has changed call SetPen to recalulate the line width */
1862     if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1863         (m_pen.Ok()))
1864     {
1865       /* this is a bit artificial, but we need to force wxDC to think
1866          the pen has changed */
1867       wxPen pen = m_pen;
1868       m_pen = wxNullPen;
1869       SetPen( pen );
1870   }
1871 }
1872
1873 wxSize wxWindowDC::GetPPI() const
1874 {
1875     return wxSize(100, 100);
1876 }
1877
1878 int wxWindowDC::GetDepth() const
1879 {
1880     wxFAIL_MSG(wxT("not implemented"));
1881
1882     return -1;
1883 }
1884
1885 // ----------------------------------------------------------------------------
1886 // wxPaintDC
1887 // ----------------------------------------------------------------------------
1888
1889 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
1890
1891 wxPaintDC::wxPaintDC(wxWindow* win)
1892   : wxClientDC(win)
1893 {
1894 #if USE_PAINT_REGION
1895     if (!win->GetClipPaintRegion())
1896         return;
1897
1898     m_paintClippingRegion = win->GetUpdateRegion();
1899     Region region = (Region) m_paintClippingRegion.GetX11Region();
1900     if (region)
1901     {
1902         m_paintClippingRegion = win->GetUpdateRegion();
1903         Region region2 = (Region) m_paintClippingRegion.GetX11Region();
1904         if (region2)
1905         {
1906             m_currentClippingRegion.Union( m_paintClippingRegion );
1907
1908             XSetRegion( (Display*) m_display, (GC) m_penGC, region2 );
1909             XSetRegion( (Display*) m_display, (GC) m_brushGC, region2 );
1910             XSetRegion( (Display*) m_display, (GC) m_textGC, region2 );
1911             XSetRegion( (Display*) m_display, (GC) m_bgGC, region2 );
1912         }
1913     }
1914 #endif // USE_PAINT_REGION
1915 }
1916
1917 //-----------------------------------------------------------------------------
1918 // wxClientDC
1919 //-----------------------------------------------------------------------------
1920
1921 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
1922
1923 wxClientDC::wxClientDC( wxWindow *win )
1924           : wxWindowDC( win )
1925 {
1926     wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
1927
1928 #ifdef __WXUNIVERSAL__
1929     wxPoint ptOrigin = win->GetClientAreaOrigin();
1930     SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
1931     wxSize size = win->GetClientSize();
1932     SetClippingRegion(wxPoint(0, 0), size);
1933 #endif // __WXUNIVERSAL__
1934 }
1935
1936 void wxClientDC::DoGetSize(int *width, int *height) const
1937 {
1938     wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
1939
1940     m_owner->GetClientSize( width, height );
1941 }
1942
1943 // ----------------------------------------------------------------------------
1944 // wxDCModule
1945 // ----------------------------------------------------------------------------
1946
1947 class wxDCModule : public wxModule
1948 {
1949 public:
1950     bool OnInit();
1951     void OnExit();
1952
1953 private:
1954     DECLARE_DYNAMIC_CLASS(wxDCModule)
1955 };
1956
1957 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
1958
1959 bool wxDCModule::OnInit()
1960 {
1961     wxInitGCPool();
1962     return TRUE;
1963 }
1964
1965 void wxDCModule::OnExit()
1966 {
1967     wxCleanUpGCPool();
1968 }