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