src/motif/dcclient.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dcclient.cpp
   3 // Purpose:     wxClientDC class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:       wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 /*
  13    About pens, brushes, and the autoSetting flag:
  14
  15    Under X, pens and brushes control some of the same X drawing
  16    parameters. Therefore, it is impossible to independently maintain
  17    the current pen and the current brush. Also, some settings depend
  18    on the current logical function. The m_currentFill, etc. instance
  19    variables remember state across the brush and pen.
  20
  21    Since pens are used more than brushes, the autoSetting flag
  22    is used to indicate that a brush was recently used, and SetPen
  23    must be called to reinstall the current pen's parameters.
  24    If autoSetting includes 0x2, then the pens color may need
  25    to be set based on XOR.
  26
  27    There is, unfortunately, some confusion between setting the
  28    current pen/brush and actually installing the brush/pen parameters.
  29    Both functionalies are perform by SetPen and SetBrush. C'est la vie.
  30 */
  31
  32 #ifdef __GNUG__
  33 #pragma implementation "dcclient.h"
  34 #endif
  35
  36 #include "wx/dcclient.h"
  37 #include "wx/dcmemory.h"
  38 #include "wx/window.h"
  39 #include "wx/app.h"
  40 #include <math.h>
  41
  42 #include <Xm/Xm.h>
  43
  44 #include "wx/motif/private.h"
  45
  46 #include "bdiag.xbm"
  47 #include "fdiag.xbm"
  48 #include "cdiag.xbm"
  49 #include "horiz.xbm"
  50 #include "verti.xbm"
  51 #include "cross.xbm"
  52
  53 static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
  54
  55 //-----------------------------------------------------------------------------
  56 // constants
  57 //-----------------------------------------------------------------------------
  58
  59 #define RAD2DEG 57.2957795131
  60 // Fudge factor. Obsolete?
  61 #define WX_GC_CF 0
  62
  63 //-----------------------------------------------------------------------------
  64 // wxWindowDC
  65 //-----------------------------------------------------------------------------
  66
  67 #if !USE_SHARED_LIBRARY
  68 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
  69 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
  70 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
  71 #endif
  72
  73 wxWindowDC::wxWindowDC(void)
  74 {
  75     m_gc = (WXGC) 0;
  76     m_gcBacking = (WXGC) 0;
  77     m_window = NULL;
  78     m_backgroundPixel = -1;
  79     m_currentPenWidth = 1;
  80     m_currentPenJoin = -1;
  81     m_currentPenDashCount = -1;
  82     m_currentPenDash = (char*) NULL;
  83     m_currentStyle = -1;
  84     m_currentFill = -1;
  85 //    m_currentBkMode = wxTRANSPARENT;
  86     m_colour = wxColourDisplay();
  87     m_display = (WXDisplay*) NULL;
  88     m_currentRegion = (WXRegion) 0;
  89     m_userRegion = (WXRegion) 0;
  90     m_pixmap = (WXPixmap) 0;
  91     m_autoSetting = 0;
  92     m_oldFont = (WXFont) 0;
  93 };
  94
  95 wxWindowDC::wxWindowDC( wxWindow *window )
  96 {
  97     wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );
  98
  99     m_window = window;
 100     m_gc = (WXGC) 0;
 101     m_gcBacking = (WXGC) 0;
 102     m_backgroundPixel = -1;
 103     m_currentPenWidth = 1;
 104     m_currentPenJoin = -1;
 105     m_currentPenDashCount = -1;
 106     m_currentPenDash = (char*) NULL;
 107     m_currentStyle = -1;
 108     m_currentFill = -1;
 109 //    m_currentBkMode = wxTRANSPARENT;
 110     m_colour = wxColourDisplay();
 111     m_currentRegion = (WXRegion) 0;
 112     m_userRegion = (WXRegion) 0;
 113     m_ok = TRUE;
 114     m_autoSetting = 0;
 115
 116     m_display = window->GetXDisplay();
 117     m_pixmap = window->GetXWindow();
 118     Display* display = (Display*) m_display;
 119
 120     XSetWindowColormap (display, (Pixmap) m_pixmap, (Colormap) wxTheApp->GetMainColormap(m_display));
 121
 122     XGCValues gcvalues;
 123     gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
 124     gcvalues.background = WhitePixel (display, DefaultScreen (display));
 125     gcvalues.graphics_exposures = False;
 126     gcvalues.line_width = 1;
 127     m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
 128         GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
 129           &gcvalues);
 130
 131     if (m_window->GetBackingPixmap())
 132     {
 133       m_gcBacking = (WXGC) XCreateGC (display, RootWindow (display,
 134                           DefaultScreen (display)),
 135         GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
 136              &gcvalues);
 137     }
 138
 139     m_backgroundPixel = (int) gcvalues.background;
 140
 141     // Get the current Font so we can set it back later
 142     XGCValues valReturn;
 143     XGetGCValues((Display*) m_display, (GC) m_gc, GCFont, &valReturn);
 144     m_oldFont = (WXFont) valReturn.font;
 145 };
 146
 147 wxWindowDC::~wxWindowDC(void)
 148 {
 149     if (m_gc && (m_oldFont != (WXFont) 0) && ((long) m_oldFont != -1))
 150     {
 151       XSetFont ((Display*) m_display, (GC) m_gc, (Font) m_oldFont);
 152
 153       if (m_window && m_window->GetBackingPixmap())
 154           XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
 155     }
 156
 157     if (m_gc)
 158         XFreeGC ((Display*) m_display, (GC) m_gc);
 159     m_gc = (WXGC) 0;
 160
 161     if (m_gcBacking)
 162         XFreeGC ((Display*) m_display, (GC) m_gcBacking);
 163     m_gcBacking = (WXGC) 0;
 164
 165     if (m_currentRegion)
 166         XDestroyRegion ((Region) m_currentRegion);
 167     m_currentRegion = (WXRegion) 0;
 168
 169     if (m_userRegion)
 170         XDestroyRegion ((Region) m_userRegion);
 171     m_userRegion = (WXRegion) 0;
 172 };
 173
 174 void wxWindowDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1),
 175   wxColour* WXUNUSED(col), int WXUNUSED(style) )
 176 {
 177   // TODO
 178 };
 179
 180 bool wxWindowDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
 181 {
 182   // TODO
 183   return FALSE;
 184 };
 185
 186 void wxWindowDC::DrawLine( long x1, long y1, long x2, long y2 )
 187 {
 188   if (!Ok()) return;
 189
 190   int x1d, y1d, x2d, y2d;
 191
 192   //  FreeGetPixelCache();
 193
 194   x1d = XLOG2DEV(x1);
 195   y1d = YLOG2DEV(y1);
 196   x2d = XLOG2DEV(x2);
 197   y2d = YLOG2DEV(y2);
 198
 199   if (m_autoSetting)
 200     SetPen (m_pen);
 201
 202   XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x1d, y1d, x2d, y2d);
 203
 204   if (m_window && m_window->GetBackingPixmap())
 205     XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
 206            XLOG2DEV_2(x1), YLOG2DEV_2(y1),
 207            XLOG2DEV_2(x2), YLOG2DEV_2(y2));
 208
 209   CalcBoundingBox(x1, y1);
 210   CalcBoundingBox(x2, y2);
 211 };
 212
 213 void wxWindowDC::CrossHair( long x, long y )
 214 {
 215   if (!Ok()) return;
 216
 217   if (m_autoSetting)
 218     SetPen (m_pen);
 219
 220   int xx = XLOG2DEV (x);
 221   int yy = YLOG2DEV (y);
 222   int ww, hh;
 223   wxDisplaySize (&ww, &hh);
 224   XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, yy,
 225          ww, yy);
 226   XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xx, 0,
 227          xx, hh);
 228
 229   if (m_window && m_window->GetBackingPixmap())
 230     {
 231       xx = XLOG2DEV_2 (x);
 232       yy = YLOG2DEV_2 (y);
 233       XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
 234          0, yy,
 235          ww, yy);
 236       XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
 237          xx, 0,
 238          xx, hh);
 239     }
 240 };
 241
 242 void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
 243 {
 244   if (!Ok()) return;
 245
 246 //  FreeGetPixelCache();
 247
 248   int xx1 = XLOG2DEV (x1);
 249   int yy1 = YLOG2DEV (y1);
 250   int xx2 = XLOG2DEV (x2);
 251   int yy2 = YLOG2DEV (y2);
 252   int xxc = XLOG2DEV (xc);
 253   int yyc = YLOG2DEV (yc);
 254   int xxc_2 = XLOG2DEV_2 (xc);
 255   int yyc_2 = YLOG2DEV_2 (yc);
 256
 257   long dx = xx1 - xxc;
 258   long dy = yy1 - yyc;
 259   double radius = sqrt (dx * dx + dy * dy);
 260   long r = (long) radius;
 261
 262   double radius1, radius2;
 263
 264   if (xx1 == xx2 && yy1 == yy2)
 265     {
 266       radius1 = 0.0;
 267       radius2 = 360.0;
 268     }
 269   else if (radius == 0.0)
 270     radius1 = radius2 = 0.0;
 271   else
 272     {
 273       if (xx1 - xxc == 0)
 274     if (yy1 - yyc < 0)
 275       radius1 = 90.0;
 276     else
 277       radius1 = -90.0;
 278       else
 279     radius1 = -atan2 ((double) (yy1 - yyc), (double) (xx1 - xxc)) * 360.0 / (2 * M_PI);
 280
 281       if (xx2 - xxc == 0)
 282     if (yy2 - yyc < 0)
 283       radius2 = 90.0;
 284     else
 285       radius2 = -90.0;
 286       else
 287     radius2 = -atan2 ((double) (yy2 - yyc), (double) (xx2 - xxc)) * 360.0 / (2 * M_PI);
 288     }
 289   radius1 *= 64.0;
 290   radius2 *= 64.0;
 291   int alpha1 = (int) radius1;
 292   int alpha2 = (int) (radius2 - radius1);
 293   while (alpha2 <= 0)
 294     alpha2 += 360 * 64;
 295   while (alpha2 > 360 * 64)
 296     alpha2 -= 360 * 64;
 297
 298   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 299     {
 300       SetBrush (m_brush);
 301       XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
 302         xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
 303
 304       if (m_window && m_window->GetBackingPixmap())
 305       XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
 306          xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
 307
 308     }
 309
 310   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 311     {
 312         if (m_autoSetting)
 313             SetPen (m_pen);
 314       XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
 315            xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
 316
 317       if (m_window && m_window->GetBackingPixmap())
 318         XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
 319            xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
 320     }
 321   CalcBoundingBox (x1, y1);
 322   CalcBoundingBox (x2, y2);
 323 };
 324
 325 void wxWindowDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
 326 {
 327   if (!Ok()) return;
 328
 329   int xd, yd, wd, hd;
 330
 331   xd = XLOG2DEV(x);
 332   yd = YLOG2DEV(y);
 333   wd = XLOG2DEVREL(width);
 334   hd = YLOG2DEVREL(height);
 335
 336   if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
 337   if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
 338   int start = int(sa*64);
 339   int end   = int(ea*64);
 340   if (start<0) start+=360*64;
 341   if (end  <0) end  +=360*64;
 342   if (end>start) end-=start;
 343   else end+=360*64-start;
 344
 345   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 346     {
 347       m_autoSetting = TRUE;    // must be reset
 348
 349       SetBrush (m_brush);
 350       XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);
 351
 352       if (m_window && m_window->GetBackingPixmap())
 353        XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
 354           XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
 355     }
 356
 357   if (!m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 358     {
 359       if (m_autoSetting)
 360     SetPen (m_pen);
 361       XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start,end);
 362       if (m_window && m_window->GetBackingPixmap())
 363         XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
 364           XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
 365     }
 366   CalcBoundingBox (x, y);
 367   CalcBoundingBox (x + width, y + height);
 368 };
 369
 370 void wxWindowDC::DrawPoint( long x, long y )
 371 {
 372   if (!Ok()) return;
 373
 374 //  FreeGetPixelCache();
 375
 376   if (m_pen.Ok() && m_autoSetting)
 377     SetPen (m_pen);
 378
 379   XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
 380   if (m_window && m_window->GetBackingPixmap())
 381     XDrawPoint ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, XLOG2DEV_2 (x), YLOG2DEV_2 (y));
 382
 383   CalcBoundingBox (x, y);
 384 };
 385
 386 void wxWindowDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
 387 {
 388   if (!Ok()) return;
 389
 390 //  FreeGetPixelCache();
 391
 392   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 393     {
 394       if (m_autoSetting)
 395     SetPen (m_pen);
 396
 397       XPoint *xpoints = new XPoint[n];
 398       int i;
 399
 400       for (i = 0; i < n; i++)
 401     {
 402       xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
 403       xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
 404     }
 405       XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);
 406
 407     if (m_window && m_window->GetBackingPixmap())
 408     {
 409       for (i = 0; i < n; i++)
 410         {
 411           xpoints[i].x = XLOG2DEV_2 (points[i].x + xoffset);
 412           xpoints[i].y = YLOG2DEV_2 (points[i].y + yoffset);
 413         }
 414       XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints, n, 0);
 415     }
 416     delete[]xpoints;
 417   }
 418 };
 419
 420 void wxWindowDC::DrawLines( wxList *list, long xoffset, long yoffset )
 421 {
 422   if (!Ok()) return;
 423
 424   if (m_pen.GetStyle() == wxTRANSPARENT) return;
 425
 426   int n = list->Number();
 427   wxPoint *points = new wxPoint[n];
 428
 429   int i = 0;
 430   for(wxNode *node = list->First(); node; node = node->Next()) {
 431     wxPoint *point = (wxPoint *)node->Data();
 432     points[i].x = point->x;
 433     points[i++].y = point->y;
 434   }
 435   DrawLines(n, points, xoffset, yoffset);
 436   delete []points;
 437 };
 438
 439 void wxWindowDC::DrawPolygon( int n, wxPoint points[],
 440   long xoffset, long yoffset, int fillStyle )
 441 {
 442 //  FreeGetPixelCache();
 443
 444   XPoint *xpoints1 = new XPoint[n + 1];
 445   XPoint *xpoints2 = new XPoint[n + 1];
 446   int i;
 447   for (i = 0; i < n; i++)
 448     {
 449       xpoints1[i].x = XLOG2DEV (points[i].x + xoffset);
 450       xpoints1[i].y = YLOG2DEV (points[i].y + yoffset);
 451       xpoints2[i].x = XLOG2DEV_2 (points[i].x + xoffset);
 452       xpoints2[i].y = YLOG2DEV_2 (points[i].y + yoffset);
 453       CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
 454     }
 455
 456   // Close figure for XDrawLines (not needed for XFillPolygon)
 457   xpoints1[i].x = xpoints1[0].x;
 458   xpoints1[i].y = xpoints1[0].y;
 459   xpoints2[i].x = xpoints2[0].x;
 460   xpoints2[i].y = xpoints2[0].y;
 461
 462   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 463     {
 464       SetBrush (m_brush);
 465       XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
 466       XFillPolygon ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n, Complex, 0);
 467       XSetFillRule ((Display*) m_display, (GC) m_gc, EvenOddRule);    // default mode
 468       if (m_window && m_window->GetBackingPixmap())
 469       {
 470          XSetFillRule ((Display*) m_display,(GC) m_gcBacking,
 471              fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
 472          XFillPolygon ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n, Complex, 0);
 473          XSetFillRule ((Display*) m_display,(GC) m_gcBacking, EvenOddRule);    // default mode
 474       }
 475   }
 476
 477   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 478     {
 479       if (m_autoSetting)
 480         SetPen (m_pen);
 481       XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n + 1, 0);
 482
 483       if (m_window && m_window->GetBackingPixmap())
 484         XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n + 1, 0);
 485     }
 486
 487   delete[]xpoints1;
 488   delete[]xpoints2;
 489 };
 490
 491 void wxWindowDC::DrawPolygon( wxList *list, long xoffset,
 492                              long yoffset, int fillStyle )
 493 {
 494   if (!Ok()) return;
 495
 496   int n = list->Number();
 497   wxPoint *points = new wxPoint[n];
 498
 499   int i = 0;
 500   for(wxNode *node = list->First(); node; node = node->Next()) {
 501     wxPoint *point = (wxPoint *)node->Data();
 502     points[i].x = point->x;
 503     points[i++].y = point->y;
 504   }
 505   DrawPolygon(n, points, xoffset, yoffset,fillStyle);
 506   delete[] points;
 507 };
 508
 509 void wxWindowDC::DrawRectangle( long x, long y, long width, long height )
 510 {
 511   if (!Ok()) return;
 512
 513 //  FreeGetPixelCache();
 514
 515   int xd, yd, wfd, hfd, wd, hd;
 516
 517   xd = XLOG2DEV(x);
 518   yd = YLOG2DEV(y);
 519   wfd = XLOG2DEVREL(width);
 520   wd = wfd - WX_GC_CF;
 521   hfd = YLOG2DEVREL(height);
 522   hd = hfd - WX_GC_CF;
 523
 524   if (wfd == 0 || hfd == 0) return;
 525   if (wd < 0) { wd = - wd; xd = xd - wd; }
 526   if (hd < 0) { hd = - hd; yd = yd - hd; }
 527
 528   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 529     {
 530       SetBrush (m_brush);
 531       XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
 532
 533       if (m_window && m_window->GetBackingPixmap())
 534     XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 535             XLOG2DEV_2 (x), YLOG2DEV_2 (y),
 536             wfd, hfd);
 537     }
 538
 539   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 540     {
 541       if (m_autoSetting)
 542     SetPen (m_pen);
 543       XDrawRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd);
 544
 545       if (m_window && m_window->GetBackingPixmap())
 546     XDrawRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 547             XLOG2DEV_2 (x), YLOG2DEV_2 (y),
 548             wd, hd);
 549     }
 550   CalcBoundingBox (x, y);
 551   CalcBoundingBox (x + width, y + height);
 552 };
 553
 554 void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
 555 {
 556   if (!Ok()) return;
 557
 558 //  FreeGetPixelCache();
 559
 560   // If radius is negative, it's a proportion of the smaller dimension.
 561
 562   if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
 563
 564   int xd = XLOG2DEV (x);
 565   int yd = YLOG2DEV (y);
 566   int rd = XLOG2DEVREL ((long) radius);
 567   int wd = XLOG2DEVREL (width) - WX_GC_CF;
 568   int hd = YLOG2DEVREL (height) - WX_GC_CF;
 569
 570   int rw_d = rd * 2;
 571   int rh_d = rw_d;
 572
 573   // If radius is zero use DrawRectangle() instead to avoid
 574   // X drawing errors with small radii
 575   if (rd == 0)
 576   {
 577     DrawRectangle( x, y, width, height );
 578     return;
 579   }
 580
 581   // Draw nothing if transformed w or h is 0
 582   if (wd == 0 || hd == 0) return;
 583
 584   // CMB: adjust size if outline is drawn otherwise the result is
 585   // 1 pixel too wide and high
 586   if (m_pen.GetStyle() != wxTRANSPARENT)
 587   {
 588     wd--;
 589     hd--;
 590   }
 591
 592   // CMB: ensure dd is not larger than rectangle otherwise we
 593   // get an hour glass shape
 594   if (rw_d > wd) rw_d = wd;
 595   if (rw_d > hd) rw_d = hd;
 596   rd = rw_d / 2;
 597
 598   // For backing pixmap
 599   int xd2 = XLOG2DEV_2 (x);
 600   int yd2 = YLOG2DEV_2 (y);
 601   int rd2 = XLOG2DEVREL ((long) radius);
 602   int wd2 = XLOG2DEVREL (width) ;
 603   int hd2 = YLOG2DEVREL (height) ;
 604
 605   int rw_d2 = rd2 * 2;
 606   int rh_d2 = rw_d2;
 607
 608   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 609   {
 610       SetBrush (m_brush);
 611
 612       XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
 613               wd - rw_d, hd);
 614       XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
 615               wd, hd - rh_d);
 616
 617       // Arcs start from 3 o'clock, positive angles anticlockwise
 618       // Top-left
 619       XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
 620         rw_d, rh_d, 90 * 64, 90 * 64);
 621       // Top-right
 622       XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
 623 //        rw_d, rh_d, 0, 90 * 64);
 624         rw_d, rh_d, 0, 91 * 64);
 625       // Bottom-right
 626       XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
 627         yd + hd - rh_d,
 628 //        rw_d, rh_d, 270 * 64, 90 * 64);
 629         rw_d, rh_d, 269 * 64, 92 * 64);
 630       // Bottom-left
 631       XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
 632         rw_d, rh_d, 180 * 64, 90 * 64);
 633
 634     if (m_window && m_window->GetBackingPixmap())
 635     {
 636       XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 637               xd2 + rd2, yd2, wd2 - rw_d2, hd2);
 638       XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 639               xd2, yd2 + rd2, wd2, hd2 - rh_d2);
 640
 641       XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 642        xd2, yd2, rw_d2, rh_d2, 90 * 64, 90 * 64);
 643       XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 644             xd2 + wd2 - rw_d2, yd2,
 645 //            rw_d2, rh_d2, 0, 90 * 64);
 646             rw_d2, rh_d2, 0, 91 * 64);
 647       XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 648             xd2 + wd2 - rw_d2,
 649             yd2 + hd2 - rh_d2,
 650 //            rw_d2, rh_d2, 270 * 64, 90 * 64);
 651             rw_d2, rh_d2, 269 * 64, 92 * 64);
 652       XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 653             xd2, yd2 + hd2 - rh_d2,
 654             rw_d2, rh_d2, 180 * 64, 90 * 64);
 655     }
 656   }
 657
 658   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 659   {
 660       SetPen (m_pen);
 661       XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
 662          xd + wd - rd + 1, yd);
 663       XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd + hd,
 664          xd + wd - rd, yd + hd);
 665
 666       XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
 667          xd, yd + hd - rd);
 668       XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd, yd + rd,
 669          xd + wd, yd + hd - rd + 1);
 670       XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
 671         rw_d, rh_d, 90 * 64, 90 * 64);
 672       XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
 673 //        rw_d, rh_d, 0, 90 * 64);
 674         rw_d, rh_d, 0, 91 * 64);
 675       XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
 676         yd + hd - rh_d,
 677         rw_d, rh_d, 269 * 64, 92 * 64);
 678       XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
 679         rw_d, rh_d, 180 * 64, 90 * 64);
 680
 681       if (m_window && m_window->GetBackingPixmap())
 682     {
 683       XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 684              xd2 + rd2, yd2,
 685              xd2 + wd2 - rd2 + 1, yd2);
 686       XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 687              xd2 + rd2, yd2 + hd2,
 688           xd2 + wd2 - rd2, yd2 + hd2);
 689
 690       XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 691              xd2, yd2 + rd2,
 692              xd2, yd2 + hd2 - rd2);
 693       XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 694              xd2 + wd2, yd2 + rd2,
 695           xd2 + wd2, yd2 + hd2 - rd2 + 1);
 696       XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 697             xd2, yd2,
 698             rw_d2, rh_d2, 90 * 64, 90 * 64);
 699       XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 700             xd2 + wd2 - rw_d2, yd2,
 701 //            rw_d2, rh_d2, 0, 90 * 64);
 702             rw_d2, rh_d2, 0, 91 * 64);
 703       XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 704             xd2 + wd2 - rw_d2,
 705             yd2 + hd2 - rh_d2,
 706             rw_d2, rh_d2, 269 * 64, 92 * 64);
 707       XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 708             xd2, yd2 + hd2 - rh_d2,
 709             rw_d2, rh_d2, 180 * 64, 90 * 64);
 710     }
 711   }
 712   CalcBoundingBox (x, y);
 713   CalcBoundingBox (x + width, y + height);
 714
 715
 716 };
 717
 718 void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
 719 {
 720   if (!Ok()) return;
 721
 722   // Check for negative width and height
 723   if (height < 0)
 724   {
 725     y = y + height;
 726     height = - height ;
 727   }
 728
 729   if (width < 0)
 730   {
 731     x = x + width;
 732     width = - width ;
 733   }
 734
 735 //  FreeGetPixelCache();
 736
 737   static const int angle = 23040;
 738
 739   int xd, yd, wd, hd;
 740
 741   xd = XLOG2DEV(x);
 742   yd = YLOG2DEV(y);
 743   wd = XLOG2DEVREL(width) ;
 744   hd = YLOG2DEVREL(height) ;
 745
 746   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 747     {
 748       SetBrush (m_brush);
 749       XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
 750       if (m_window && m_window->GetBackingPixmap())
 751         XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 752           XLOG2DEV_2 (x), YLOG2DEV_2 (y),
 753           XLOG2DEVREL (width) - WX_GC_CF,
 754           YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
 755     }
 756
 757   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 758     {
 759       if (m_autoSetting)
 760     SetPen (m_pen);
 761       XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
 762       if (m_window && m_window->GetBackingPixmap())
 763         XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 764           XLOG2DEV_2 (x), YLOG2DEV_2 (y),
 765           XLOG2DEVREL (width) - WX_GC_CF,
 766           YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
 767     }
 768   CalcBoundingBox (x, y);
 769   CalcBoundingBox (x + width, y + height);
 770
 771 };
 772
 773 bool wxWindowDC::CanDrawBitmap(void) const
 774 {
 775   return TRUE;
 776 };
 777
 778 /* Used when copying between drawables on different (Display*) m_displays.
 779    Not very fast, but better than giving up.
 780  */
 781
 782 static void XCopyRemote(Display *src_display, Display *dest_display,
 783             Drawable src, Drawable dest,
 784             GC destgc,
 785             int srcx, int srcy,
 786             unsigned int w, unsigned int h,
 787             int destx, int desty,
 788             bool more, XImage **cache)
 789 {
 790   XImage *image, *destimage;
 791   Colormap destcm, srccm;
 792 #define CACHE_SIZE 256
 793   unsigned int i, j;
 794   unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
 795   int k, cache_pos, all_cache;
 796
 797   if (!cache || !*cache)
 798     image = XGetImage(src_display, src, srcx, srcy, w, h, AllPlanes, ZPixmap);
 799   else
 800     image = *cache;
 801
 802   destimage = XGetImage(dest_display, dest, destx, desty, w, h, AllPlanes, ZPixmap);
 803
 804   srccm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) src_display);
 805   destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
 806
 807   cache_pos = 0;
 808   all_cache = FALSE;
 809
 810   for (i = 0; i < w; i++)
 811     for (j = 0; j < h; j++) {
 812       unsigned long pixel;
 813       XColor xcol;
 814
 815       pixel = XGetPixel(image, i, j);
 816       for (k = cache_pos; k--; )
 817     if (cachesrc[k] == pixel) {
 818       pixel = cachedest[k];
 819       goto install;
 820     }
 821       if (all_cache)
 822     for (k = CACHE_SIZE; k-- > cache_pos; )
 823       if (cachesrc[k] == pixel) {
 824         pixel = cachedest[k];
 825         goto install;
 826       }
 827
 828       cachesrc[cache_pos] = xcol.pixel = pixel;
 829       XQueryColor(src_display, srccm, &xcol);
 830       if (!XAllocColor(dest_display, destcm, &xcol))
 831     xcol.pixel = 0;
 832       cachedest[cache_pos] = pixel = xcol.pixel;
 833
 834       if (++cache_pos >= CACHE_SIZE) {
 835     cache_pos = 0;
 836     all_cache = TRUE;
 837       }
 838
 839     install:
 840       XPutPixel(destimage, i, j, pixel);
 841     }
 842
 843   XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
 844   XDestroyImage(destimage);
 845
 846   if (more)
 847     *cache = image;
 848   else
 849     XDestroyImage(image);
 850 }
 851
 852 void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
 853 {
 854   if (!Ok()) return;
 855
 856   if (!icon.Ok()) return;
 857
 858 //  FreeGetPixelCache();
 859
 860   // Be sure that foreground pixels (1) of
 861   // the Icon will be painted with pen colour. [m_pen.SetColour()]
 862   // Background pixels (0) will be painted with
 863   // last selected background color. [::SetBackground]
 864   if (m_pen.Ok() && m_autoSetting)
 865     SetPen (m_pen);
 866
 867   int width, height;
 868   Pixmap iconPixmap = (Pixmap) icon.GetPixmap();
 869   width = icon.GetWidth();
 870   height = icon.GetHeight();
 871   if (icon.GetDisplay() == m_display)
 872   {
 873    if (icon.GetDepth() <= 1)
 874    {
 875        XCopyPlane  ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
 876                     0, 0, width, height,
 877                     (int) XLOG2DEV (x), (int) YLOG2DEV (y), 1);
 878    }
 879    else
 880    {
 881        XCopyArea  ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
 882                   0, 0, width, height,
 883                   (int) XLOG2DEV (x), (int) YLOG2DEV (y));
 884    }
 885
 886
 887   if (m_window && m_window->GetBackingPixmap())
 888   {
 889      if (icon.GetDepth() <= 1)
 890      {
 891         XCopyPlane ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 892           0, 0, width, height, (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), 1);
 893      }
 894      else
 895      {
 896        XCopyArea  ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 897                   0, 0, width, height,
 898                   (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y));
 899      }
 900   }
 901   } else { /* Remote copy (different (Display*) m_displays) */
 902     XImage *cache = NULL;
 903     if (m_window && m_window->GetBackingPixmap())
 904       XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),
 905          (GC) m_gcBacking, 0, 0, width, height,
 906           (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), TRUE, &cache);
 907     XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
 908         0, 0, width, height,
 909         (int) XLOG2DEV (x), (int) YLOG2DEV (y), FALSE, &cache);
 910   }
 911   CalcBoundingBox (x, y);
 912
 913 };
 914
 915 bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
 916        wxDC *source, long xsrc, long ysrc, int rop, bool useMask )
 917 {
 918   if (!Ok()) return FALSE;
 919
 920   wxASSERT_MSG( (source->IsKindOf(CLASSINFO(wxWindowDC))), "Blit source DC must be wxWindowDC or derived class." );
 921
 922   wxWindowDC* sourceDC = (wxWindowDC*) source;
 923
 924 //  FreeGetPixelCache();
 925
 926   // Be sure that foreground pixels (1) of
 927   // the Icon will be painted with pen colour. [m_pen.SetColour()]
 928   // Background pixels (0) will be painted with
 929   // last selected background color. [::SetBackground]
 930   if (m_pen.Ok() && m_autoSetting)
 931     SetPen (m_pen);
 932
 933   if (m_pixmap && sourceDC->m_pixmap)
 934     {
 935       /* MATTHEW: [9] */
 936       int orig = m_logicalFunction;
 937
 938       SetLogicalFunction (rop);
 939
 940       if (m_display != sourceDC->m_display)
 941       {
 942         XImage *cache = NULL;
 943
 944         if (m_window && m_window->GetBackingPixmap())
 945             XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,
 946               (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),
 947              (GC) m_gcBacking,
 948               source->LogicalToDeviceX (xsrc),
 949               source->LogicalToDeviceY (ysrc),
 950               source->LogicalToDeviceXRel(width),
 951               source->LogicalToDeviceYRel(height),
 952               XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
 953               TRUE, &cache);
 954
 955         if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
 956         {
 957             wxMemoryDC *memDC = (wxMemoryDC *)source;
 958             wxBitmap& sel = memDC->GetBitmap();
 959             if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
 960             {
 961                 XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
 962                 XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
 963             }
 964         }
 965
 966         XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
 967             source->LogicalToDeviceX (xsrc),
 968             source->LogicalToDeviceY (ysrc),
 969             source->LogicalToDeviceXRel(width),
 970             source->LogicalToDeviceYRel(height),
 971             XLOG2DEV (xdest), YLOG2DEV (ydest),
 972             FALSE, &cache);
 973
 974         if ( useMask )
 975         {
 976             XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
 977             XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
 978         }
 979
 980     } else
 981     {
 982       if (m_window && m_window->GetBackingPixmap())
 983       {
 984 // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
 985         if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetBitmap().GetDepth() == 1)
 986         {
 987            XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 988                    source->LogicalToDeviceX (xsrc),
 989                   source->LogicalToDeviceY (ysrc),
 990                   source->LogicalToDeviceXRel(width),
 991                   source->LogicalToDeviceYRel(height),
 992                   XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest), 1);
 993         }
 994       else
 995         {
 996            XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
 997                   source->LogicalToDeviceX (xsrc),
 998                  source->LogicalToDeviceY (ysrc),
 999                  source->LogicalToDeviceXRel(width),
1000                  source->LogicalToDeviceYRel(height),
1001                  XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest));
1002         }
1003     }
1004     if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
1005     {
1006         wxMemoryDC *memDC = (wxMemoryDC *)source;
1007         wxBitmap& sel = memDC->GetBitmap();
1008         if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
1009         {
1010             XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
1011             XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
1012         }
1013     }
1014
1015       // Check if we're copying from a mono bitmap
1016       if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
1017           ((wxMemoryDC*)source)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
1018       {
1019         XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
1020               source->LogicalToDeviceX (xsrc),
1021               source->LogicalToDeviceY (ysrc),
1022               source->LogicalToDeviceXRel(width),
1023               source->LogicalToDeviceYRel(height),
1024               XLOG2DEV (xdest), YLOG2DEV (ydest), 1);
1025       }
1026       else
1027       {
1028         XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
1029              source->LogicalToDeviceX (xsrc),
1030              source->LogicalToDeviceY (ysrc),
1031              source->LogicalToDeviceXRel(width),
1032              source->LogicalToDeviceYRel(height),
1033              XLOG2DEV (xdest), YLOG2DEV (ydest));
1034
1035       }
1036     if ( useMask )
1037     {
1038         XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
1039         XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
1040     }
1041
1042     } /* Remote/local (Display*) m_display */
1043     CalcBoundingBox (xdest, ydest);
1044     CalcBoundingBox (xdest + width, ydest + height);
1045
1046     SetLogicalFunction(orig);
1047
1048     return TRUE;
1049   }
1050   return FALSE;
1051 };
1052
1053 /* Helper function for 16-bit fonts */
1054 static int str16len(const char *s)
1055 {
1056   int count = 0;
1057
1058   while (s[0] && s[1]) {
1059     count++;
1060     s += 2;
1061   }
1062
1063   return count;
1064 }
1065
1066 void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
1067 {
1068   if (!Ok()) return;
1069
1070   // Since X draws from the baseline of the text, must
1071   // add the text height
1072   int cx = 0;
1073   int cy = 0;
1074   int ascent = 0;
1075   int slen;
1076
1077   if (use16)
1078     slen = str16len(text);
1079   else
1080     slen = strlen(text);
1081
1082   if (m_font.Ok())
1083     {
1084       WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
1085       int direction, descent;
1086       XCharStruct overall_return;
1087       if (use16)
1088         (void)XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *)(const char*) text, slen, &direction,
1089                  &ascent, &descent, &overall_return);
1090       else
1091         (void)XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) text, slen, &direction,
1092                &ascent, &descent, &overall_return);
1093       cx = overall_return.width;
1094       cy = ascent + descent;
1095     }
1096
1097   // First draw a rectangle representing the text background,
1098   // if a text background is specified
1099   if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
1100     {
1101       wxColour oldPenColour = m_currentColour;
1102       m_currentColour = m_textBackgroundColour;
1103       bool sameColour = (oldPenColour.Ok () && m_textBackgroundColour.Ok () &&
1104         (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
1105           (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
1106         (oldPenColour.Green () == m_textBackgroundColour.Green ()));
1107
1108       // This separation of the big && test required for gcc2.7/HP UX 9.02
1109       // or pixel value can be corrupted!
1110       sameColour = (sameColour &&
1111            (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
1112
1113       if (!sameColour || !GetOptimization())
1114       {
1115         int pixel = m_textBackgroundColour.AllocColour(m_display);
1116         m_currentColour = m_textBackgroundColour;
1117
1118         // Set the GC to the required colour
1119         if (pixel > -1)
1120         {
1121           XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
1122           if (m_window && m_window->GetBackingPixmap())
1123             XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
1124         }
1125       }
1126       else
1127         m_textBackgroundColour = oldPenColour ;
1128
1129       XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y), cx, cy);
1130       if (m_window && m_window->GetBackingPixmap())
1131         XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
1132             XLOG2DEV_2 (x), YLOG2DEV_2 (y), cx, cy);
1133     }
1134
1135   // Now set the text foreground and draw the text
1136   if (m_textForegroundColour.Ok ())
1137   {
1138       wxColour oldPenColour = m_currentColour;
1139       m_currentColour = m_textForegroundColour;
1140       bool sameColour = (oldPenColour.Ok () && m_currentColour.Ok () &&
1141               (oldPenColour.Red () == m_currentColour.Red ()) &&
1142                (oldPenColour.Blue () == m_currentColour.Blue ()) &&
1143              (oldPenColour.Green () == m_currentColour.Green ()) &&
1144               (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
1145
1146       if (!sameColour || !GetOptimization())
1147       {
1148         int pixel = -1;
1149         if (!m_colour) // Mono display
1150         {
1151           // Unless foreground is really white, draw it in black
1152           unsigned char red = m_textForegroundColour.Red ();
1153           unsigned char blue = m_textForegroundColour.Blue ();
1154           unsigned char green = m_textForegroundColour.Green ();
1155           if (red == (unsigned char) 255 && blue == (unsigned char) 255
1156                 && green == (unsigned char) 255)
1157           {
1158             m_currentColour = *wxWHITE;
1159             pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
1160             m_currentColour.SetPixel(pixel);
1161             m_textForegroundColour.SetPixel(pixel);
1162           }
1163           else
1164           {
1165             m_currentColour = *wxBLACK;
1166             pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
1167             m_currentColour.SetPixel(pixel);
1168             m_textForegroundColour.SetPixel(pixel);
1169           }
1170         }
1171         else
1172         {
1173             pixel = m_textForegroundColour.AllocColour((Display*) m_display);
1174             m_currentColour.SetPixel(pixel);
1175         }
1176
1177         // Set the GC to the required colour
1178         if (pixel > -1)
1179         {
1180             XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
1181             if (m_window && m_window->GetBackingPixmap())
1182               XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
1183         }
1184       }
1185       else
1186         m_textForegroundColour = oldPenColour;
1187   }
1188
1189   // We need to add the ascent, not the whole height, since X draws
1190   // at the point above the descender.
1191   if (use16)
1192     XDrawString16((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent,
1193           (XChar2b *)(char*) (const char*) text, slen);
1194   else
1195     XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent,
1196         text, slen);
1197
1198   if (m_window && m_window->GetBackingPixmap()) {
1199     if (use16)
1200       XDrawString16((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
1201             XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
1202             (XChar2b *)(char*) (const char*) text, slen);
1203     else
1204       XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
1205           XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent, (char*) (const char*) text, slen);
1206   }
1207
1208   long w, h;
1209   GetTextExtent (text, &w, &h);
1210   CalcBoundingBox (x + w, y + h);
1211   CalcBoundingBox (x, y);
1212 };
1213
1214 bool wxWindowDC::CanGetTextExtent(void) const
1215 {
1216   return TRUE;
1217 };
1218
1219 void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
1220                      long *descent, long *externalLeading,
1221                      wxFont *font, bool use16 )
1222 {
1223   if (!Ok()) return;
1224
1225   wxFont* theFont = font;
1226   if (!theFont)
1227      theFont = & m_font;
1228
1229   if (!theFont->Ok())
1230   {
1231     // TODO: this should be an error log function
1232     cerr << "wxWindows warning - set a valid font before calling GetTextExtent!\n";
1233     *width = -1;
1234     *height = -1;
1235     return;
1236   }
1237
1238   WXFontStructPtr pFontStruct = theFont->GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
1239
1240   int direction, ascent, descent2;
1241   XCharStruct overall;
1242   int slen;
1243
1244   if (use16) slen = str16len(string); else slen = strlen(string);
1245
1246   if (use16)
1247     XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
1248            &ascent, &descent2, &overall);
1249   else
1250      XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
1251          &ascent, &descent2, &overall);
1252
1253   *width = XDEV2LOGREL (overall.width);
1254   *height = YDEV2LOGREL (ascent + descent2);
1255   if (descent)
1256     *descent = descent2;
1257   if (externalLeading)
1258     *externalLeading = 0;
1259 };
1260
1261 long wxWindowDC::GetCharWidth(void)
1262 {
1263   if (!Ok()) return 0;
1264
1265   if (!m_font.Ok())
1266     return 0;
1267
1268   WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY * m_logicalScaleY, m_display);
1269
1270   int direction, ascent, descent;
1271   XCharStruct overall;
1272   XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1273         &descent, &overall);
1274   return XDEV2LOGREL(overall.width);
1275 };
1276
1277 long wxWindowDC::GetCharHeight(void)
1278 {
1279   if (!Ok()) return 0;
1280
1281   if (!m_font.Ok())
1282     return 0;
1283
1284   WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
1285
1286   int direction, ascent, descent;
1287   XCharStruct overall;
1288   XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1289         &descent, &overall);
1290 //  return XDEV2LOGREL(overall.ascent + overall.descent);
1291   return XDEV2LOGREL(ascent + descent);
1292 };
1293
1294 void wxWindowDC::Clear(void)
1295 {
1296   if (!Ok()) return;
1297
1298   int w, h;
1299   if (m_window)
1300     {
1301       // TODO: should we get the virtual size?
1302       m_window->GetSize(&w, &h);
1303
1304       if (m_window && m_window->GetBackingPixmap())
1305       {
1306         w = m_window->GetPixmapWidth();
1307         h = m_window->GetPixmapHeight();
1308       }
1309     }
1310   else
1311     {
1312         if (this->IsKindOf(CLASSINFO(wxMemoryDC)))
1313         {
1314            wxMemoryDC* memDC = (wxMemoryDC*) this;
1315            w = memDC->GetBitmap().GetWidth();
1316            h = memDC->GetBitmap().GetHeight();
1317         }
1318         else
1319           return;
1320     }
1321
1322   wxBrush saveBrush = m_brush;
1323   SetBrush (m_backgroundBrush);
1324
1325   XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, 0, w, h);
1326
1327   if (m_window && m_window->GetBackingPixmap())
1328     XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, 0, 0, w, h);
1329
1330   m_brush = saveBrush;
1331 };
1332
1333 void wxWindowDC::SetFont( const wxFont &font )
1334 {
1335   if (!Ok()) return;
1336
1337   m_font = font;
1338
1339   if (!m_font.Ok())
1340   {
1341     if ((m_oldFont != (WXFont) 0) && ((long) m_oldFont != -1))
1342     {
1343       XSetFont ((Display*) m_display, (GC) m_gc, (Font) m_oldFont);
1344
1345       if (m_window && m_window->GetBackingPixmap())
1346           XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
1347     }
1348     return;
1349   }
1350
1351   WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
1352
1353   Font fontId = ((XFontStruct*)pFontStruct)->fid;
1354   XSetFont ((Display*) m_display, (GC) m_gc, fontId);
1355
1356   if (m_window && m_window->GetBackingPixmap())
1357       XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
1358 };
1359
1360 void wxWindowDC::SetPen( const wxPen &pen )
1361 {
1362   if (!Ok()) return;
1363
1364   m_pen = pen;
1365   if (!m_pen.Ok())
1366     return;
1367
1368   wxBitmap oldStipple = m_currentStipple;
1369   int oldStyle = m_currentStyle;
1370   int oldFill = m_currentFill;
1371   int old_pen_width = m_currentPenWidth;
1372   int old_pen_join = m_currentPenJoin;
1373   int old_pen_cap = m_currentPenCap;
1374   int old_pen_nb_dash = m_currentPenDashCount;
1375   char *old_pen_dash = m_currentPenDash;
1376
1377   wxColour oldPenColour = m_currentColour;
1378   m_currentColour = m_pen.GetColour ();
1379   m_currentStyle = m_pen.GetStyle ();
1380   m_currentFill = m_pen.GetStyle (); // TODO?
1381   m_currentPenWidth = m_pen.GetWidth ();
1382   m_currentPenJoin = m_pen.GetJoin ();
1383   m_currentPenCap = m_pen.GetCap ();
1384   m_currentPenDashCount = m_pen.GetDashCount();
1385   m_currentPenDash = m_pen.GetDash();
1386
1387   if (m_currentStyle == wxSTIPPLE)
1388     m_currentStipple = m_pen.GetStipple ();
1389
1390   bool sameStyle = (oldStyle == m_currentStyle &&
1391              oldFill == m_currentFill &&
1392              old_pen_join == m_currentPenJoin &&
1393              old_pen_cap == m_currentPenCap &&
1394              old_pen_nb_dash == m_currentPenDashCount &&
1395              old_pen_dash == m_currentPenDash &&
1396              old_pen_width == m_currentPenWidth);
1397
1398   bool sameColour = (oldPenColour.Ok () &&
1399               (oldPenColour.Red () == m_currentColour.Red ()) &&
1400               (oldPenColour.Blue () == m_currentColour.Blue ()) &&
1401               (oldPenColour.Green () == m_currentColour.Green ()) &&
1402               (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
1403
1404   if (!sameStyle || !GetOptimization())
1405     {
1406       int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
1407       if (scaled_width < 0)
1408         scaled_width = 0;
1409
1410       int style;
1411       int join;
1412       int cap;
1413       static char dotted[] =
1414       {2, 5};
1415       static char short_dashed[] =
1416       {4, 4};
1417       static char long_dashed[] =
1418       {4, 8};
1419       static char dotted_dashed[] =
1420       {6, 6, 2, 6};
1421
1422       // We express dash pattern in pen width unit, so we are
1423       // independent of zoom factor and so on...
1424       int req_nb_dash;
1425       char *req_dash;
1426
1427       switch (m_pen.GetStyle ())
1428       {
1429         case wxUSER_DASH:
1430           req_nb_dash = m_currentPenDashCount;
1431           req_dash = m_currentPenDash;
1432           style = LineOnOffDash;
1433           break;
1434         case wxDOT:
1435           req_nb_dash = 2;
1436           req_dash = dotted;
1437           style = LineOnOffDash;
1438           break;
1439         case wxSHORT_DASH:
1440           req_nb_dash = 2;
1441           req_dash = short_dashed;
1442           style = LineOnOffDash;
1443           break;
1444         case wxLONG_DASH:
1445           req_nb_dash = 2;
1446           req_dash = long_dashed;
1447           style = LineOnOffDash;
1448           break;
1449         case wxDOT_DASH:
1450           req_nb_dash = 4;
1451           req_dash = dotted_dashed;
1452           style = LineOnOffDash;
1453           break;
1454         case wxSTIPPLE:
1455         case wxSOLID:
1456         case wxTRANSPARENT:
1457         default:
1458           style = LineSolid;
1459           req_dash = NULL;
1460           req_nb_dash = 0;
1461       }
1462
1463       if (req_dash && req_nb_dash)
1464       {
1465         char *real_req_dash = new char[req_nb_dash];
1466         if (real_req_dash)
1467         {
1468           int factor = scaled_width == 0 ? 1 : scaled_width;
1469           for (int i = 0; i < req_nb_dash; i++)
1470           real_req_dash[i] = req_dash[i] * factor;
1471           XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);
1472
1473           if (m_window && m_window->GetBackingPixmap())
1474           XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, real_req_dash, req_nb_dash);
1475           delete[]real_req_dash;
1476         }
1477         else
1478         {
1479           // No Memory. We use non-scaled dash pattern...
1480           XSetDashes ((Display*) m_display, (GC) m_gc, 0, req_dash, req_nb_dash);
1481
1482           if (m_window && m_window->GetBackingPixmap())
1483           XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, req_dash, req_nb_dash);
1484         }
1485       }
1486
1487       switch (m_pen.GetCap ())
1488       {
1489         case wxCAP_PROJECTING:
1490           cap = CapProjecting;
1491           break;
1492         case wxCAP_BUTT:
1493           cap = CapButt;
1494           break;
1495         case wxCAP_ROUND:
1496         default:
1497           cap = CapRound;
1498           break;
1499       }
1500
1501       switch (m_pen.GetJoin ())
1502       {
1503         case wxJOIN_BEVEL:
1504           join = JoinBevel;
1505           break;
1506         case wxJOIN_MITER:
1507           join = JoinMiter;
1508           break;
1509         case wxJOIN_ROUND:
1510         default:
1511           join = JoinRound;
1512           break;
1513       }
1514
1515       XSetLineAttributes ((Display*) m_display, (GC) m_gc, scaled_width, style, cap, join);
1516
1517       if (m_window && m_window->GetBackingPixmap())
1518         XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
1519     }
1520
1521     if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
1522     {
1523       Pixmap myStipple;
1524
1525       oldStipple = NULL;    // For later reset!!
1526
1527       switch (m_currentFill)
1528       {
1529         case wxBDIAGONAL_HATCH:
1530           if (bdiag == (Pixmap) 0)
1531             bdiag = XCreateBitmapFromData ((Display*) m_display,
1532                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1533                          bdiag_bits, bdiag_width, bdiag_height);
1534           myStipple = bdiag;
1535           break;
1536         case wxFDIAGONAL_HATCH:
1537           if (fdiag == (Pixmap) 0)
1538             fdiag = XCreateBitmapFromData ((Display*) m_display,
1539                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1540                          fdiag_bits, fdiag_width, fdiag_height);
1541           myStipple = fdiag;
1542           break;
1543         case wxCROSS_HATCH:
1544           if (cross == (Pixmap) 0)
1545             cross = XCreateBitmapFromData ((Display*) m_display,
1546                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1547                          cross_bits, cross_width, cross_height);
1548           myStipple = cross;
1549           break;
1550         case wxHORIZONTAL_HATCH:
1551           if (horiz == (Pixmap) 0)
1552             horiz = XCreateBitmapFromData ((Display*) m_display,
1553                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1554                          horiz_bits, horiz_width, horiz_height);
1555           myStipple = horiz;
1556           break;
1557         case wxVERTICAL_HATCH:
1558           if (verti == (Pixmap) 0)
1559             verti = XCreateBitmapFromData ((Display*) m_display,
1560                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1561                          verti_bits, verti_width, verti_height);
1562           myStipple = verti;
1563           break;
1564         case wxCROSSDIAG_HATCH:
1565         default:
1566           if (cdiag == (Pixmap) 0)
1567             cdiag = XCreateBitmapFromData ((Display*) m_display,
1568                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1569                          cdiag_bits, cdiag_width, cdiag_height);
1570           myStipple = cdiag;
1571           break;
1572       }
1573       XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
1574
1575       if (m_window && m_window->GetBackingPixmap())
1576         XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
1577     }
1578     else if (m_currentStipple.Ok()
1579        && ((m_currentStipple != oldStipple) || !GetOptimization()))
1580     {
1581       XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
1582
1583       if (m_window && m_window->GetBackingPixmap())
1584         XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
1585     }
1586
1587     if ((m_currentFill != oldFill) || !GetOptimization())
1588     {
1589       int fill_style;
1590
1591       if (m_currentFill == wxSTIPPLE)
1592         fill_style = FillStippled;
1593       else if (IS_HATCH (m_currentFill))
1594         fill_style = FillStippled;
1595       else
1596         fill_style = FillSolid;
1597       XSetFillStyle ((Display*) m_display, (GC) m_gc, fill_style);
1598       if (m_window && m_window->GetBackingPixmap())
1599         XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, fill_style);
1600     }
1601
1602     // must test m_logicalFunction, because it involves background!
1603     if (!sameColour || !GetOptimization()
1604       || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
1605     {
1606       int pixel = -1;
1607       if (m_pen.GetStyle () == wxTRANSPARENT)
1608         pixel = m_backgroundPixel;
1609       else if (!m_colour)
1610       {
1611         unsigned char red = m_pen.GetColour ().Red ();
1612         unsigned char blue = m_pen.GetColour ().Blue ();
1613         unsigned char green = m_pen.GetColour ().Green ();
1614         if (red == (unsigned char) 255 && blue == (unsigned char) 255
1615             && green == (unsigned char) 255)
1616         {
1617           pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
1618           m_currentColour = *wxWHITE;
1619           m_pen.GetColour().SetPixel(pixel);
1620           m_currentColour.SetPixel(pixel);
1621         }
1622         else
1623         {
1624           pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
1625           m_currentColour = *wxBLACK;
1626           m_pen.GetColour().SetPixel(pixel);
1627         }
1628       }
1629       else
1630       {
1631         pixel = m_pen.GetColour ().AllocColour(m_display);
1632         m_currentColour.SetPixel(pixel);
1633       }
1634
1635       // Finally, set the GC to the required colour
1636       if (pixel > -1)
1637       {
1638         if (m_logicalFunction == wxXOR)
1639         {
1640           XGCValues values;
1641           XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
1642           XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
1643           if (m_window && m_window->GetBackingPixmap())
1644             XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
1645         }
1646       else
1647         {
1648           XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
1649           if (m_window && m_window->GetBackingPixmap())
1650             XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
1651         }
1652     }
1653   }
1654   else
1655     m_pen.GetColour().SetPixel(oldPenColour.GetPixel());
1656
1657   m_autoSetting = 0;
1658 };
1659
1660 void wxWindowDC::SetBrush( const wxBrush &brush )
1661 {
1662   if (!Ok()) return;
1663
1664   m_brush = brush;
1665
1666   if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
1667     return;
1668
1669   int oldFill = m_currentFill;
1670   wxBitmap oldStipple = m_currentStipple;
1671
1672   m_autoSetting |= 0x1;
1673
1674   m_currentFill = m_brush.GetStyle ();
1675   if (m_currentFill == wxSTIPPLE)
1676     m_currentStipple = m_brush.GetStipple ();
1677
1678   wxColour oldBrushColour(m_currentColour);
1679   m_currentColour = m_brush.GetColour ();
1680
1681   bool sameColour = (oldBrushColour.Ok () &&
1682               (oldBrushColour.Red () == m_currentColour.Red ()) &&
1683               (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
1684            (oldBrushColour.Green () == m_currentColour.Green ()) &&
1685               (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));
1686
1687   if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
1688   {
1689       switch (brush.GetStyle ())
1690       {
1691         case wxTRANSPARENT:
1692           break;
1693         case wxBDIAGONAL_HATCH:
1694         case wxCROSSDIAG_HATCH:
1695         case wxFDIAGONAL_HATCH:
1696         case wxCROSS_HATCH:
1697         case wxHORIZONTAL_HATCH:
1698         case wxVERTICAL_HATCH:
1699         case wxSTIPPLE:
1700           {
1701             // Chris Breeze 23/07/97: use background mode to determine whether
1702             // fill style should be solid or transparent
1703             int style = (m_backgroundMode == wxSOLID ? FillOpaqueStippled : FillStippled);
1704             XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
1705             if (m_window && m_window->GetBackingPixmap())
1706               XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, style);
1707           }
1708           break;
1709         case wxSOLID:
1710         default:
1711           XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
1712           if (m_window && m_window->GetBackingPixmap())
1713             XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, FillSolid);
1714       }
1715   }
1716
1717   if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
1718     {
1719       Pixmap myStipple;
1720
1721       switch (m_currentFill)
1722       {
1723         case wxBDIAGONAL_HATCH:
1724           if (bdiag == (Pixmap) 0)
1725             bdiag = XCreateBitmapFromData ((Display*) m_display,
1726                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1727                          bdiag_bits, bdiag_width, bdiag_height);
1728           myStipple = bdiag;
1729           break;
1730         case wxFDIAGONAL_HATCH:
1731           if (fdiag == (Pixmap) 0)
1732             fdiag = XCreateBitmapFromData ((Display*) m_display,
1733                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1734                          fdiag_bits, fdiag_width, fdiag_height);
1735           myStipple = fdiag;
1736           break;
1737         case wxCROSS_HATCH:
1738           if (cross == (Pixmap) 0)
1739             cross = XCreateBitmapFromData ((Display*) m_display,
1740                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1741                          cross_bits, cross_width, cross_height);
1742           myStipple = cross;
1743           break;
1744         case wxHORIZONTAL_HATCH:
1745           if (horiz == (Pixmap) 0)
1746             horiz = XCreateBitmapFromData ((Display*) m_display,
1747                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1748                          horiz_bits, horiz_width, horiz_height);
1749           myStipple = horiz;
1750           break;
1751         case wxVERTICAL_HATCH:
1752           if (verti == (Pixmap) 0)
1753             verti = XCreateBitmapFromData ((Display*) m_display,
1754                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1755                          verti_bits, verti_width, verti_height);
1756           myStipple = verti;
1757           break;
1758         case wxCROSSDIAG_HATCH:
1759         default:
1760           if (cdiag == (Pixmap) 0)
1761             cdiag = XCreateBitmapFromData ((Display*) m_display,
1762                       RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
1763                          cdiag_bits, cdiag_width, cdiag_height);
1764           myStipple = cdiag;
1765           break;
1766       }
1767       XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
1768
1769       if (m_window && m_window->GetBackingPixmap())
1770         XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
1771     }
1772     // X can forget the stipple value when resizing a window (apparently)
1773     // so always set the stipple.
1774     else if (m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
1775     {
1776       XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
1777       if (m_window && m_window->GetBackingPixmap())
1778         XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
1779     }
1780
1781     // must test m_logicalFunction, because it involves background!
1782     if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
1783     {
1784       int pixel = -1;
1785       if (!m_colour)
1786       {
1787           // Policy - on a monochrome screen, all brushes are white,
1788           // except when they're REALLY black!!!
1789           unsigned char red = m_brush.GetColour ().Red ();
1790           unsigned char blue = m_brush.GetColour ().Blue ();
1791           unsigned char green = m_brush.GetColour ().Green ();
1792
1793           if (red == (unsigned char) 0 && blue == (unsigned char) 0
1794               && green == (unsigned char) 0)
1795             {
1796               pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
1797               m_currentColour = *wxBLACK;
1798               m_brush.GetColour().SetPixel(pixel);
1799               m_currentColour.SetPixel(pixel);
1800             }
1801           else
1802             {
1803               pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
1804               m_currentColour = *wxWHITE;
1805               m_brush.GetColour().SetPixel(pixel);
1806               m_currentColour.SetPixel(pixel);
1807             }
1808
1809           // N.B. comment out the above line and uncomment the following lines
1810           // if you want non-white colours to be black on a monochrome display.
1811           /*
1812              if (red == (unsigned char )255 && blue == (unsigned char)255
1813              && green == (unsigned char)255)
1814              pixel = (int)WhitePixel((Display*) m_display, DefaultScreen((Display*) m_display));
1815              else
1816              pixel = (int)BlackPixel((Display*) m_display, DefaultScreen((Display*) m_display));
1817            */
1818       }
1819       else if (m_brush.GetStyle () != wxTRANSPARENT)
1820       {
1821         pixel = m_brush.GetColour().AllocColour(m_display);
1822         m_currentColour.SetPixel(pixel);
1823       }
1824       if (pixel > -1)
1825       {
1826         // Finally, set the GC to the required colour
1827         if (m_logicalFunction == wxXOR)
1828         {
1829           XGCValues values;
1830           XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
1831           XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
1832           if (m_window && m_window->GetBackingPixmap())
1833             XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
1834         }
1835         else
1836         {
1837           XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
1838           if (m_window && m_window->GetBackingPixmap())
1839             XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
1840         }
1841       }
1842     }
1843   else
1844     m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
1845 };
1846
1847 void wxWindowDC::SetBackground( const wxBrush &brush )
1848 {
1849   if (!Ok()) return;
1850
1851   m_backgroundBrush = brush;
1852
1853   if (!m_backgroundBrush.Ok())
1854     return;
1855
1856   int pixel = m_backgroundBrush.GetColour().AllocColour(m_display);
1857
1858   // XSetWindowBackground doesn't work for non-Window pixmaps
1859   if (!this->IsKindOf(CLASSINFO(wxMemoryDC)))
1860       XSetWindowBackground ((Display*) m_display, (Pixmap) m_pixmap, pixel);
1861
1862   // Necessary for ::DrawIcon, which use fg/bg pixel or the GC.
1863   // And Blit,... (Any fct that use XCopyPlane, in fact.)
1864   XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
1865   if (m_window && m_window->GetBackingPixmap())
1866      XSetBackground ((Display*) m_display,(GC) m_gcBacking, pixel);
1867 };
1868
1869 void wxWindowDC::SetLogicalFunction( int function )
1870 {
1871   int x_function;
1872
1873   /* MATTHEW: [9] */
1874   if (m_logicalFunction == function)
1875     return;
1876
1877   switch (function)
1878     {
1879     case wxCLEAR:
1880       x_function = GXclear;
1881       break;
1882     case wxXOR:
1883       x_function = GXxor;
1884       break;
1885     case wxINVERT:
1886       x_function = GXinvert;
1887       break;
1888     case wxOR_REVERSE:
1889       x_function = GXorReverse;
1890       break;
1891     case wxAND_REVERSE:
1892       x_function = GXandReverse;
1893       break;
1894     case wxAND:
1895       x_function = GXand;
1896       break;
1897     case wxOR:
1898       x_function = GXor;
1899       break;
1900     case wxAND_INVERT:
1901       x_function = GXandInverted;
1902       break;
1903     case wxNO_OP:
1904       x_function = GXnoop;
1905       break;
1906     case wxNOR:
1907       x_function = GXnor;
1908       break;
1909     case wxEQUIV:
1910       x_function = GXequiv;
1911       break;
1912     case wxSRC_INVERT:
1913       x_function = GXcopyInverted;
1914       break;
1915     case wxOR_INVERT:
1916       x_function = GXorInverted;
1917       break;
1918     case wxNAND:
1919       x_function = GXnand;
1920       break;
1921     case wxSET:
1922       x_function = GXset;
1923       break;
1924     case wxCOPY:
1925     default:
1926       x_function = GXcopy;
1927       break;
1928     }
1929
1930   XSetFunction((Display*) m_display, (GC) m_gc, x_function);
1931   if (m_window && m_window->GetBackingPixmap())
1932     XSetFunction((Display*) m_display, (GC) m_gcBacking, x_function);
1933
1934   if ((m_logicalFunction == wxXOR) != (function == wxXOR))
1935     /* MATTHEW: [9] Need to redo pen simply */
1936     m_autoSetting |= 0x2;
1937
1938   m_logicalFunction = function;
1939
1940 };
1941
1942 void wxWindowDC::SetTextForeground( const wxColour &col )
1943 {
1944   if (!Ok()) return;
1945
1946   if (m_textForegroundColour == col) return;
1947
1948   m_textForegroundColour = col;
1949
1950 };
1951
1952 void wxWindowDC::SetTextBackground( const wxColour &col )
1953 {
1954   if (!Ok()) return;
1955
1956   if (m_textBackgroundColour == col) return;
1957
1958   m_textBackgroundColour = col;
1959   if (!m_textBackgroundColour.Ok()) return;
1960 };
1961
1962 void wxWindowDC::SetBackgroundMode( int mode )
1963 {
1964   m_backgroundMode = mode;
1965
1966 };
1967
1968 void wxWindowDC::SetPalette( const wxPalette& palette )
1969 {
1970   if (m_window)
1971   {
1972     if (palette.Ok())
1973       /* Use GetXColormap */
1974       XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1975               (Colormap) palette.GetXColormap());
1976     else
1977       /* Use wxGetMainColormap */
1978       XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1979               (Colormap) wxTheApp->GetMainColormap(m_display));
1980   }
1981 };
1982
1983 // Helper function
1984 void wxWindowDC:: SetDCClipping ()
1985 {
1986   // m_userRegion is the region set by calling SetClippingRegion
1987
1988   if (m_currentRegion)
1989     XDestroyRegion ((Region) m_currentRegion);
1990
1991   // We need to take into account
1992   // clipping imposed on a window by a repaint.
1993   // We'll combine it with the user region. But for now,
1994   // just use the currently-defined user clipping region.
1995   if (m_userRegion || (m_window && m_window->GetPaintRegion()) )
1996     m_currentRegion = (WXRegion) XCreateRegion ();
1997   else
1998     m_currentRegion = (WXRegion) NULL;
1999
2000   if ((m_window && m_window->GetPaintRegion()) && m_userRegion)
2001     XIntersectRegion ((Region) m_window->GetPaintRegion(), (Region) m_userRegion, (Region) m_currentRegion);
2002   else if (m_userRegion)
2003     XIntersectRegion ((Region) m_userRegion, (Region) m_userRegion, (Region) m_currentRegion);
2004   else if (m_window && m_window->GetPaintRegion())
2005     XIntersectRegion ((Region) m_window->GetPaintRegion(), (Region) m_window->GetPaintRegion(),
2006 (Region) m_currentRegion);
2007
2008   if (m_currentRegion)
2009     {
2010       XSetRegion ((Display*) m_display, (GC) m_gc, (Region) m_currentRegion);
2011     }
2012   else
2013     {
2014       XSetClipMask ((Display*) m_display, (GC) m_gc, None);
2015     }
2016
2017 }
2018
2019 void wxWindowDC::SetClippingRegion( long x, long y, long width, long height )
2020 {
2021   wxDC::SetClippingRegion( x, y, width, height );
2022
2023   if (m_userRegion)
2024     XDestroyRegion ((Region) m_userRegion);
2025   m_userRegion = (WXRegion) XCreateRegion ();
2026   XRectangle r;
2027   r.x = XLOG2DEV (x);
2028   r.y = YLOG2DEV (y);
2029   r.width = XLOG2DEVREL(width);
2030   r.height = YLOG2DEVREL(height);
2031   XUnionRectWithRegion (&r, (Region) m_userRegion, (Region) m_userRegion);
2032
2033   SetDCClipping ();
2034
2035   // Needs to work differently for Pixmap: without this,
2036   // there's a nasty (Display*) m_display bug. 8/12/94
2037   if (m_window && m_window->GetBackingPixmap())
2038   {
2039     XRectangle rects[1];
2040     rects[0].x = XLOG2DEV_2(x);
2041     rects[0].y = YLOG2DEV_2(y);
2042     rects[0].width = XLOG2DEVREL(width);
2043     rects[0].height = YLOG2DEVREL(height);
2044     XSetClipRectangles((Display*) m_display, (GC) m_gcBacking, 0, 0, rects, 1, Unsorted);
2045   }
2046 };
2047
2048 void wxWindowDC::DestroyClippingRegion(void)
2049 {
2050   wxDC::DestroyClippingRegion();
2051
2052   if (m_userRegion)
2053     XDestroyRegion ((Region) m_userRegion);
2054   m_userRegion = NULL;
2055
2056   SetDCClipping ();
2057
2058   XGCValues gc_val;
2059   gc_val.clip_mask = None;
2060   if (m_window && m_window->GetBackingPixmap())
2061     XChangeGC((Display*) m_display, (GC) m_gcBacking, GCClipMask, &gc_val);
2062 };
2063
2064 // ----------------------------------- spline code ----------------------------------------
2065
2066 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
2067                          double a3, double b3, double a4, double b4);
2068 void wx_clear_stack(void);
2069 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
2070         double *y3, double *x4, double *y4);
2071 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
2072           double x4, double y4);
2073 static bool wx_spline_add_point(double x, double y);
2074 static void wx_spline_draw_point_array(wxDC *dc);
2075
2076 wxList wx_spline_point_list;
2077
2078 #define        half(z1, z2)    ((z1+z2)/2.0)
2079 #define        THRESHOLD    5
2080
2081 /* iterative version */
2082
2083 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
2084                  double b4)
2085 {
2086     register double  xmid, ymid;
2087     double           x1, y1, x2, y2, x3, y3, x4, y4;
2088
2089     wx_clear_stack();
2090     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
2091
2092     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
2093         xmid = (double)half(x2, x3);
2094         ymid = (double)half(y2, y3);
2095     if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
2096         fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
2097             wx_spline_add_point( x1, y1 );
2098             wx_spline_add_point( xmid, ymid );
2099     } else {
2100             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
2101                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
2102             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
2103                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
2104     }
2105     }
2106 }
2107
2108 /* utilities used by spline drawing routines */
2109
2110 typedef struct wx_spline_stack_struct {
2111     double           x1, y1, x2, y2, x3, y3, x4, y4;
2112 } Stack;
2113
2114 #define         SPLINE_STACK_DEPTH             20
2115 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
2116 static Stack   *wx_stack_top;
2117 static int      wx_stack_count;
2118
2119 void wx_clear_stack(void)
2120 {
2121     wx_stack_top = wx_spline_stack;
2122     wx_stack_count = 0;
2123 }
2124
2125 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
2126 {
2127     wx_stack_top->x1 = x1;
2128     wx_stack_top->y1 = y1;
2129     wx_stack_top->x2 = x2;
2130     wx_stack_top->y2 = y2;
2131     wx_stack_top->x3 = x3;
2132     wx_stack_top->y3 = y3;
2133     wx_stack_top->x4 = x4;
2134     wx_stack_top->y4 = y4;
2135     wx_stack_top++;
2136     wx_stack_count++;
2137 }
2138
2139 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
2140                   double *x3, double *y3, double *x4, double *y4)
2141 {
2142     if (wx_stack_count == 0)
2143     return (0);
2144     wx_stack_top--;
2145     wx_stack_count--;
2146     *x1 = wx_stack_top->x1;
2147     *y1 = wx_stack_top->y1;
2148     *x2 = wx_stack_top->x2;
2149     *y2 = wx_stack_top->y2;
2150     *x3 = wx_stack_top->x3;
2151     *y3 = wx_stack_top->y3;
2152     *x4 = wx_stack_top->x4;
2153     *y4 = wx_stack_top->y4;
2154     return (1);
2155 }
2156
2157 static bool wx_spline_add_point(double x, double y)
2158 {
2159   wxPoint *point = new wxPoint ;
2160   point->x = (int) x;
2161   point->y = (int) y;
2162   wx_spline_point_list.Append((wxObject*)point);
2163   return TRUE;
2164 }
2165
2166 static void wx_spline_draw_point_array(wxDC *dc)
2167 {
2168   dc->DrawLines(&wx_spline_point_list, 0, 0 );
2169   wxNode *node = wx_spline_point_list.First();
2170   while (node)
2171   {
2172     wxPoint *point = (wxPoint *)node->Data();
2173     delete point;
2174     delete node;
2175     node = wx_spline_point_list.First();
2176   }
2177 }
2178
2179 void wxWindowDC::DrawSpline( wxList *points )
2180 {
2181     wxPoint *p;
2182     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
2183     double           x1, y1, x2, y2;
2184
2185     wxNode *node = points->First();
2186     p = (wxPoint *)node->Data();
2187
2188     x1 = p->x;
2189     y1 = p->y;
2190
2191     node = node->Next();
2192     p = (wxPoint *)node->Data();
2193
2194     x2 = p->x;
2195     y2 = p->y;
2196     cx1 = (double)((x1 + x2) / 2);
2197     cy1 = (double)((y1 + y2) / 2);
2198     cx2 = (double)((cx1 + x2) / 2);
2199     cy2 = (double)((cy1 + y2) / 2);
2200
2201     wx_spline_add_point(x1, y1);
2202
2203     while ((node = node->Next()) != NULL)
2204     {
2205         p = (wxPoint *)node->Data();
2206     x1 = x2;
2207     y1 = y2;
2208     x2 = p->x;
2209     y2 = p->y;
2210         cx4 = (double)(x1 + x2) / 2;
2211         cy4 = (double)(y1 + y2) / 2;
2212         cx3 = (double)(x1 + cx4) / 2;
2213         cy3 = (double)(y1 + cy4) / 2;
2214
2215         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
2216
2217     cx1 = cx4;
2218     cy1 = cy4;
2219         cx2 = (double)(cx1 + x2) / 2;
2220         cy2 = (double)(cy1 + y2) / 2;
2221     }
2222
2223     wx_spline_add_point( cx1, cy1 );
2224     wx_spline_add_point( x2, y2 );
2225
2226     wx_spline_draw_point_array( this );
2227 };