src/mgl/dc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mgl/dc.cpp
   3 // Purpose:     wxDC class
   4 // Author:      Vaclav Slavik
   5 // Created:     2001/03/09
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // ===========================================================================
  12 // declarations
  13 // ===========================================================================
  14
  15 // ---------------------------------------------------------------------------
  16 // headers
  17 // ---------------------------------------------------------------------------
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #ifndef WX_PRECOMP
  27     #include "wx/dc.h"
  28     #include "wx/dcmemory.h"
  29     #include "wx/log.h"
  30 #endif
  31
  32 #include "wx/fontutil.h"
  33 #include "wx/encinfo.h"
  34 #include "wx/fontmap.h"
  35 #include "wx/mgl/private.h"
  36
  37 #include <string.h>
  38 #include <mgraph.hpp>
  39
  40
  41
  42 //-----------------------------------------------------------------------------
  43 // constants
  44 //-----------------------------------------------------------------------------
  45
  46 const double RAD2DEG        = 180.0 / M_PI;
  47
  48
  49 //-----------------------------------------------------------------------------
  50 // pens data:
  51 //-----------------------------------------------------------------------------
  52
  53 const ushort STIPPLE_wxDOT        = 0x5555/* - - - - - - - -*/;
  54 const ushort STIPPLE_wxLONG_DASH  = 0xF0F0/*    ----    ----*/;
  55 const ushort STIPPLE_wxSHORT_DASH = 0xCCCC/*--  --  --  --  */;
  56 const ushort STIPPLE_wxDOT_DASH   = 0x3939/*  ---  -  ---  -*/;
  57 const ushort STIPPLE_wxSOLID      = 0xFFFF/*----------------*/;
  58
  59 #define PATTERN_ROW(b7,b6,b5,b4,b3,b2,b1,b0) \
  60             ((b7 << 7) | (b6 << 6) | (b5 << 5) | (b4 << 4) | \
  61              (b3 << 3) | (b2 << 2) | (b1 << 1) | b0)
  62
  63 static pattern_t PATTERN_wxFDIAGONAL_HATCH = {{
  64        PATTERN_ROW(1,0,0,0,0,0,0,0),
  65        PATTERN_ROW(0,1,0,0,0,0,0,0),
  66        PATTERN_ROW(0,0,1,0,0,0,0,0),
  67        PATTERN_ROW(0,0,0,1,0,0,0,0),
  68        PATTERN_ROW(0,0,0,0,1,0,0,0),
  69        PATTERN_ROW(0,0,0,0,0,1,0,0),
  70        PATTERN_ROW(0,0,0,0,0,0,1,0),
  71        PATTERN_ROW(0,0,0,0,0,0,0,1),
  72        }};
  73
  74 static pattern_t PATTERN_wxCROSSDIAG_HATCH = {{
  75        PATTERN_ROW(1,0,0,0,0,0,0,1),
  76        PATTERN_ROW(0,1,0,0,0,0,1,0),
  77        PATTERN_ROW(0,0,1,0,0,1,0,0),
  78        PATTERN_ROW(0,0,0,1,1,0,0,0),
  79        PATTERN_ROW(0,0,0,1,1,0,0,0),
  80        PATTERN_ROW(0,0,1,0,0,1,0,0),
  81        PATTERN_ROW(0,1,0,0,0,0,1,0),
  82        PATTERN_ROW(1,0,0,0,0,0,0,1),
  83        }};
  84
  85 static pattern_t PATTERN_wxBDIAGONAL_HATCH = {{
  86        PATTERN_ROW(0,0,0,0,0,0,0,1),
  87        PATTERN_ROW(0,0,0,0,0,0,1,0),
  88        PATTERN_ROW(0,0,0,0,0,1,0,0),
  89        PATTERN_ROW(0,0,0,0,1,0,0,0),
  90        PATTERN_ROW(0,0,0,1,0,0,0,0),
  91        PATTERN_ROW(0,0,1,0,0,0,0,0),
  92        PATTERN_ROW(0,1,0,0,0,0,0,0),
  93        PATTERN_ROW(1,0,0,0,0,0,0,0),
  94        }};
  95
  96 static pattern_t PATTERN_wxCROSS_HATCH = {{
  97        PATTERN_ROW(0,0,0,1,0,0,0,0),
  98        PATTERN_ROW(0,0,0,1,0,0,0,0),
  99        PATTERN_ROW(0,0,0,1,0,0,0,0),
 100        PATTERN_ROW(1,1,1,1,1,1,1,1),
 101        PATTERN_ROW(0,0,0,1,0,0,0,0),
 102        PATTERN_ROW(0,0,0,1,0,0,0,0),
 103        PATTERN_ROW(0,0,0,1,0,0,0,0),
 104        PATTERN_ROW(0,0,0,1,0,0,0,0),
 105        }};
 106
 107 static pattern_t PATTERN_wxHORIZONTAL_HATCH = {{
 108        PATTERN_ROW(0,0,0,0,0,0,0,0),
 109        PATTERN_ROW(0,0,0,0,0,0,0,0),
 110        PATTERN_ROW(0,0,0,0,0,0,0,0),
 111        PATTERN_ROW(1,1,1,1,1,1,1,1),
 112        PATTERN_ROW(0,0,0,0,0,0,0,0),
 113        PATTERN_ROW(0,0,0,0,0,0,0,0),
 114        PATTERN_ROW(0,0,0,0,0,0,0,0),
 115        PATTERN_ROW(0,0,0,0,0,0,0,0),
 116        }};
 117
 118 static pattern_t PATTERN_wxVERTICAL_HATCH = {{
 119        PATTERN_ROW(0,0,0,1,0,0,0,0),
 120        PATTERN_ROW(0,0,0,1,0,0,0,0),
 121        PATTERN_ROW(0,0,0,1,0,0,0,0),
 122        PATTERN_ROW(0,0,0,1,0,0,0,0),
 123        PATTERN_ROW(0,0,0,1,0,0,0,0),
 124        PATTERN_ROW(0,0,0,1,0,0,0,0),
 125        PATTERN_ROW(0,0,0,1,0,0,0,0),
 126        PATTERN_ROW(0,0,0,1,0,0,0,0),
 127        }};
 128
 129 #undef PATTERN_ROW
 130
 131 //-----------------------------------------------------------------------------
 132 // wxDC
 133 //-----------------------------------------------------------------------------
 134
 135 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
 136
 137 // Default constructor
 138 wxDC::wxDC()
 139 {
 140     m_isMemDC = false;
 141     m_MGLDC = NULL;
 142     m_OwnsMGLDC = false;
 143     m_ok = false; // must call SetMGLDevCtx() before using it
 144
 145     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
 146                     (double)wxGetDisplaySizeMM().GetWidth();
 147     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
 148                     (double)wxGetDisplaySizeMM().GetHeight();
 149
 150     m_pen = *wxBLACK_PEN;
 151     m_font = *wxNORMAL_FONT;
 152     m_brush = *wxWHITE_BRUSH;
 153     m_penOfsX = m_penOfsY = 0;
 154
 155     m_penSelected = m_brushSelected = false;
 156     m_downloadedPatterns[0] = m_downloadedPatterns[1] = false;
 157
 158     m_mglFont = NULL;
 159 }
 160
 161
 162 wxDC::~wxDC()
 163 {
 164     if (m_OwnsMGLDC)
 165         delete m_MGLDC;
 166 }
 167
 168 void wxDC::SetMGLDC(MGLDevCtx *mgldc, bool OwnsMGLDC)
 169 {
 170     if ( m_OwnsMGLDC && m_MGLDC )
 171         delete m_MGLDC;
 172     m_MGLDC = mgldc;
 173     m_OwnsMGLDC = OwnsMGLDC;
 174     m_ok = true;
 175
 176     if ( !m_globalClippingRegion.IsNull() )
 177         SetClippingRegion(m_globalClippingRegion);
 178
 179     InitializeMGLDC();
 180 }
 181
 182 void wxDC::InitializeMGLDC()
 183 {
 184     if ( GetDepth() > 8 )
 185     {
 186         wxCurrentDCSwitcher switcher(m_MGLDC); // will go away with MGL6
 187         m_MGLDC->setFontBlendMode(MGL_AA_RGBBLEND);
 188     }
 189 }
 190
 191
 192 // ---------------------------------------------------------------------------
 193 // clipping
 194 // ---------------------------------------------------------------------------
 195
 196
 197 #define DO_SET_CLIPPING_BOX(rg)                      \
 198 {                                                    \
 199     wxRect rect = rg.GetBox();                       \
 200     m_clipX1 = (wxCoord) XDEV2LOG(rect.GetLeft());   \
 201     m_clipY1 = (wxCoord) YDEV2LOG(rect.GetTop());    \
 202     m_clipX2 = (wxCoord) XDEV2LOG(rect.GetRight());  \
 203     m_clipY2 = (wxCoord) YDEV2LOG(rect.GetBottom()); \
 204 }
 205
 206 void wxDC::DoSetClippingRegion(wxCoord cx, wxCoord cy, wxCoord cw, wxCoord ch)
 207 {
 208     wxCHECK_RET( Ok(), wxT("invalid dc") );
 209
 210     wxRect rect(XLOG2DEV(cx), YLOG2DEV(cy), XLOG2DEVREL(cw), YLOG2DEVREL(ch));
 211
 212     if ( !m_currentClippingRegion.IsNull() )
 213         m_currentClippingRegion.Intersect(rect);
 214     else
 215         m_currentClippingRegion.Union(rect);
 216
 217     m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
 218
 219     m_clipping = true;
 220     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 221 }
 222
 223 void wxDC::DoSetDeviceClippingRegion(const wxRegion& region)
 224 {
 225     wxCHECK_RET( Ok(), wxT("invalid dc") );
 226
 227     if ( region.IsEmpty() )
 228     {
 229         DestroyClippingRegion();
 230         return;
 231     }
 232
 233     wxRegion rg(region);
 234
 235     // check if the DC is scaled or moved, and if yes, then
 236     // convert rg to device coordinates:
 237     if ( m_deviceOriginX != 0 || m_deviceOriginY != 0 ||
 238          m_logicalOriginX != 0 || m_logicalOriginY != 0 ||
 239          XLOG2DEVREL(500) != 500 || YLOG2DEVREL(500) != 500 )
 240     {
 241         region_t *mrg = rg.GetMGLRegion().rgnPointer();
 242         span_t *s;
 243         segment_t *p;
 244         for (s = mrg->spans; s; s = s->next)
 245         {
 246             s->y = YLOG2DEV(s->y);
 247             for (p = s->seg; p; p = p->next)
 248                 p->x = XLOG2DEV(p->x);
 249         }
 250     }
 251
 252     if ( !m_currentClippingRegion.IsNull() )
 253         m_currentClippingRegion.Intersect(rg);
 254     else
 255         m_currentClippingRegion.Union(rg);
 256
 257     m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
 258
 259     m_clipping = true;
 260     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 261 }
 262
 263 void wxDC::DestroyClippingRegion()
 264 {
 265     wxCHECK_RET( Ok(), wxT("invalid dc") );
 266
 267     if ( !m_globalClippingRegion.IsNull() )
 268     {
 269         m_MGLDC->setClipRegion(m_globalClippingRegion.GetMGLRegion());
 270         m_currentClippingRegion = m_globalClippingRegion;
 271         m_clipping = true;
 272     }
 273     else
 274     {
 275         m_MGLDC->setClipRect(MGLRect(0, 0, m_MGLDC->sizex()+1, m_MGLDC->sizey()+1));
 276         ResetClipping();
 277         m_currentClippingRegion.Clear();
 278     }
 279 }
 280
 281 // ---------------------------------------------------------------------------
 282 // query capabilities
 283 // ---------------------------------------------------------------------------
 284
 285 bool wxDC::CanDrawBitmap() const
 286 {
 287     return true;
 288 }
 289
 290 bool wxDC::CanGetTextExtent() const
 291 {
 292     return true;
 293 }
 294
 295 int wxDC::GetDepth() const
 296 {
 297     return m_MGLDC->getBitsPerPixel();
 298 }
 299
 300 // ---------------------------------------------------------------------------
 301 // drawing
 302 // ---------------------------------------------------------------------------
 303
 304 void wxDC::Clear()
 305 {
 306     wxCHECK_RET( Ok(), wxT("invalid dc") );
 307
 308     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 309     if ( m_backgroundBrush.GetStyle() != wxTRANSPARENT )
 310     {
 311         int w, h;
 312         wxBrush oldb = m_brush;
 313         SetBrush(m_backgroundBrush);
 314         SelectBrush();
 315         GetSize(&w, &h);
 316         m_MGLDC->fillRect(0, 0, w, h);
 317         SetBrush(oldb);
 318     }
 319 }
 320
 321 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
 322                           const wxColour & col, wxFloodFillStyle style);
 323
 324 bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
 325                        const wxColour& col, wxFloodFillStyle style)
 326 {
 327     return wxDoFloodFill(this, x, y, col, style);
 328 }
 329
 330 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 331 {
 332     wxCHECK_MSG( col, false, wxT("NULL colour parameter in wxDC::GetPixel"));
 333
 334     uchar r, g, b;
 335     m_MGLDC->unpackColorFast(m_MGLDC->getPixel(XLOG2DEV(x), YLOG2DEV(y)),
 336                              r, g, b);
 337     col->Set(r, g, b);
 338     return true;
 339 }
 340
 341 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 342 {
 343     wxCHECK_RET( Ok(), wxT("invalid dc") );
 344
 345     if ( m_pen.GetStyle() != wxTRANSPARENT )
 346     {
 347         int w = 0;
 348         int h = 0;
 349         GetSize(&w, &h);
 350         m_MGLDC->makeCurrent(); // will go away with MGL6.0
 351         if ( !m_penSelected )
 352             SelectPen();
 353         wxCoord xx = XLOG2DEV(x);
 354         wxCoord yy = YLOG2DEV(y);
 355         m_MGLDC->line(m_penOfsX, yy + m_penOfsY, w-1 + m_penOfsX, yy + m_penOfsY);
 356         m_MGLDC->line(xx + m_penOfsX, m_penOfsY, x + m_penOfsX, h-1 + m_penOfsY);
 357         CalcBoundingBox(0, 0);
 358         CalcBoundingBox(w, h);
 359     }
 360 }
 361
 362 void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 363 {
 364     wxCHECK_RET( Ok(), wxT("invalid dc") );
 365
 366     if ( m_pen.GetStyle() != wxTRANSPARENT )
 367     {
 368         m_MGLDC->makeCurrent(); // will go away with MGL6.0
 369         if ( !m_penSelected )
 370             SelectPen();
 371         m_MGLDC->lineExt(XLOG2DEV(x1) + m_penOfsX, YLOG2DEV(y1) + m_penOfsY,
 372                       XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY,FALSE);
 373         CalcBoundingBox(x1, y1);
 374         CalcBoundingBox(x2, y2);
 375     }
 376 }
 377
 378 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
 379 // and ending at (x2, y2)
 380 void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
 381                      wxCoord x2, wxCoord y2,
 382                      wxCoord xc, wxCoord yc)
 383 {
 384     wxCHECK_RET( Ok(), wxT("invalid dc") );
 385
 386     wxCoord xx1 = XLOG2DEV(x1);
 387     wxCoord yy1 = YLOG2DEV(y1);
 388     wxCoord xx2 = XLOG2DEV(x2);
 389     wxCoord yy2 = YLOG2DEV(y2);
 390     wxCoord xxc = XLOG2DEV(xc);
 391     wxCoord yyc = YLOG2DEV(yc);
 392     double dx = xx1 - xxc;
 393     double dy = yy1 - yyc;
 394     double radius = sqrt((double)(dx*dx+dy*dy));
 395     wxCoord r = (wxCoord)radius;
 396     double radius1, radius2;
 397
 398
 399     if (xx1 == xx2 && yy1 == yy2)
 400     {
 401         radius1 = 0.0;
 402         radius2 = 360.0;
 403     }
 404     else if (radius == 0.0)
 405     {
 406         radius1 = radius2 = 0.0;
 407     }
 408     else
 409     {
 410         radius1 = (xx1 - xxc == 0) ?
 411             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 412             -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
 413         radius2 = (xx2 - xxc == 0) ?
 414             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 415             -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
 416     }
 417     wxCoord alpha1 = wxCoord(radius1);
 418     wxCoord alpha2 = alpha1 + wxCoord(radius2 - radius1);
 419     while (alpha2 <= 0) alpha2 += 360;
 420     while (alpha1 > 360) alpha1 -= 360;
 421
 422     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 423     if ( m_brush.GetStyle() != wxTRANSPARENT )
 424     {
 425         if ( !m_brushSelected )
 426             SelectBrush();
 427         m_MGLDC->fillEllipseArc(xxc, yyc, r, r, alpha1, alpha2);
 428     }
 429
 430     if ( m_pen.GetStyle() != wxTRANSPARENT )
 431     {
 432         if ( !m_penSelected )
 433          SelectPen();
 434         m_MGLDC->ellipseArc(xxc + m_penOfsX, yyc + m_penOfsY, r, r, alpha1, alpha2);
 435     }
 436
 437     CalcBoundingBox(xc - r, yc - r);
 438     CalcBoundingBox(xc + r, yc + r);
 439 }
 440
 441 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
 442 {
 443     wxCHECK_RET( Ok(), wxT("invalid dc") );
 444
 445     if ( m_pen.GetStyle() != wxTRANSPARENT )
 446     {
 447         m_MGLDC->makeCurrent(); // will go away with MGL6.0
 448         if ( !m_penSelected )
 449             SelectPen();
 450         m_MGLDC->pixel(XLOG2DEV(x), YLOG2DEV(y));
 451         CalcBoundingBox(x, y);
 452     }
 453 }
 454
 455 void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,wxPolygonFillMode WXUNUSED(fillStyle))
 456 {
 457     wxCHECK_RET( Ok(), wxT("invalid dc") );
 458
 459     wxCoord xxoffset = XLOG2DEVREL(xoffset),
 460             yyoffset = YLOG2DEVREL(yoffset);
 461     MGLPoint *cpoints = new MGLPoint[n+1];
 462     for (int i = 0; i < n; i++)
 463     {
 464         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
 465         cpoints[i].x = (int)(XLOG2DEV(points[i].x));
 466         cpoints[i].y = (int)(YLOG2DEV(points[i].y));
 467     }
 468     cpoints[n] = cpoints[0];
 469
 470     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 471     if ( m_brush.GetStyle() != wxTRANSPARENT )
 472     {
 473         if ( !m_brushSelected )
 474             SelectBrush();
 475         m_MGLDC->fillPolygon(n, cpoints, xxoffset, yyoffset);
 476     }
 477
 478     if ( m_pen.GetStyle() != wxTRANSPARENT )
 479     {
 480         if ( !m_penSelected )
 481             SelectPen();
 482         if (m_penOfsX != 0 || m_penOfsY != 0)
 483         {
 484             for (int i = 0; i <= n; i++)
 485             {
 486                 cpoints[i].x += m_penOfsX;
 487                 cpoints[i].y += m_penOfsY;
 488             }
 489         }
 490         m_MGLDC->polyLine(n+1, cpoints);
 491     }
 492
 493     delete[] cpoints;
 494 }
 495
 496 void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
 497 {
 498     wxCHECK_RET( Ok(), wxT("invalid dc") );
 499
 500     if ( m_pen.GetStyle() != wxTRANSPARENT )
 501     {
 502         MGLPoint *cpoints = new MGLPoint[n];
 503         m_MGLDC->makeCurrent(); // will go away with MGL6.0
 504         if ( !m_penSelected )
 505             SelectPen();
 506         for (int i = 0; i < n; i++)
 507         {
 508             CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
 509             cpoints[i].x = (int)(XLOG2DEV(points[i].x + xoffset) /*+ m_penOfsX*/);
 510             cpoints[i].y = (int)(YLOG2DEV(points[i].y + yoffset) /*+ m_penOfsY*/);
 511         }
 512         m_MGLDC->polyLine(n, cpoints);
 513         delete[] cpoints;
 514     }
 515 }
 516
 517 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 518 {
 519     wxCHECK_RET( Ok(), wxT("invalid dc") );
 520
 521     wxCoord xx = XLOG2DEV(x);
 522     wxCoord yy = YLOG2DEV(y);
 523     wxCoord ww = m_signX * XLOG2DEVREL(width);
 524     wxCoord hh = m_signY * YLOG2DEVREL(height);
 525
 526     if ( ww == 0 || hh == 0 ) return;
 527
 528     if ( ww < 0 )
 529     {
 530         ww = -ww;
 531         xx = xx - ww;
 532     }
 533     if ( hh < 0 )
 534     {
 535         hh = -hh;
 536         yy = yy - hh;
 537     }
 538
 539     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 540     if ( m_brush.GetStyle() != wxTRANSPARENT )
 541     {
 542         if ( !m_brushSelected )
 543             SelectBrush();
 544         m_MGLDC->fillRect(xx, yy, xx + ww, yy + hh);
 545     }
 546
 547     if ( m_pen.GetStyle() != wxTRANSPARENT )
 548     {
 549         if ( !m_penSelected )
 550             SelectPen();
 551
 552         m_MGLDC->rect(xx + m_penOfsX, yy + m_penOfsY,
 553                       xx + ww + m_penOfsX, yy + hh + m_penOfsY);
 554     }
 555
 556     CalcBoundingBox(x, y);
 557     CalcBoundingBox(x + width, y + height);
 558 }
 559
 560 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
 561 {
 562     wxCHECK_RET( Ok(), wxT("invalid dc") );
 563
 564     if ( radius < 0.0 )
 565         radius = -radius * ((width < height) ? width : height);
 566
 567     wxCoord xx = XLOG2DEV(x);
 568     wxCoord yy = YLOG2DEV(y);
 569     wxCoord ww = m_signX * XLOG2DEVREL(width);
 570     wxCoord hh = m_signY * YLOG2DEVREL(height);
 571     wxCoord rr = XLOG2DEVREL((wxCoord)radius);
 572
 573     // CMB: handle -ve width and/or height
 574     if ( ww < 0 )
 575     {
 576         ww = -ww;
 577         xx = xx - ww;
 578     }
 579     if ( hh < 0 )
 580     {
 581         hh = -hh;
 582         yy = yy - hh;
 583     }
 584
 585     // CMB: if radius is zero use DrawRectangle() instead to avoid
 586     // X drawing errors with small radii
 587     if ( rr == 0 )
 588     {
 589         DrawRectangle(x, y, width, height);
 590         return;
 591     }
 592
 593     // CMB: draw nothing if transformed w or h is 0
 594     if ( ww == 0 || hh == 0 ) return;
 595
 596     // CMB: ensure dd is not larger than rectangle otherwise we
 597     // get an hour glass shape
 598     wxCoord dd = 2 * rr;
 599     if ( dd > ww ) dd = ww;
 600     if ( dd > hh ) dd = hh;
 601     rr = dd / 2;
 602
 603     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 604     if ( m_brush.GetStyle() != wxTRANSPARENT )
 605     {
 606         if (!m_brushSelected)
 607             SelectBrush();
 608         m_MGLDC->fillRect(xx+rr, yy, xx+ww-rr, yy+hh);
 609         m_MGLDC->fillRect(xx, yy+rr, xx+ww, yy+hh-rr);
 610         m_MGLDC->fillEllipseArc(xx+rr, yy+rr, rr, rr, 90, 180);
 611         m_MGLDC->fillEllipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
 612         m_MGLDC->fillEllipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);
 613         m_MGLDC->fillEllipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);
 614     }
 615
 616     if ( m_pen.GetStyle() != wxTRANSPARENT )
 617     {
 618         if ( !m_penSelected )
 619             SelectPen();
 620         xx += m_penOfsX;
 621         yy += m_penOfsY;
 622         m_MGLDC->line(xx+rr+1, yy, xx+ww-rr, yy);
 623         m_MGLDC->ellipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
 624         m_MGLDC->line(xx+ww, yy+rr+1, xx+ww, yy+hh-rr);
 625         m_MGLDC->ellipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);
 626         m_MGLDC->line(xx+ww-rr, yy+hh, xx+rr+1, yy+hh);
 627         m_MGLDC->ellipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);
 628         m_MGLDC->line(xx, yy+hh-rr, xx, yy+rr+1);
 629         m_MGLDC->ellipseArc(xx+rr, yy+rr, rr, rr, 90, 180);
 630     }
 631
 632     CalcBoundingBox(x, y);
 633     CalcBoundingBox(x + width, y + height);
 634 }
 635
 636 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 637 {
 638     wxCHECK_RET( Ok(), wxT("invalid dc") );
 639
 640     wxCoord x2 = (x+width);
 641     wxCoord y2 = (y+height);
 642
 643     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 644     if ( m_brush.GetStyle() != wxTRANSPARENT )
 645     {
 646         if ( !m_brushSelected )
 647             SelectBrush();
 648         MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
 649         m_MGLDC->fillEllipse(rect);
 650     }
 651
 652     if ( m_pen.GetStyle() != wxTRANSPARENT )
 653     {
 654         if ( !m_penSelected )
 655             SelectPen();
 656         MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,
 657                      XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
 658         m_MGLDC->ellipse(rect);
 659     }
 660
 661     CalcBoundingBox(x, y);
 662     CalcBoundingBox(x2, y2);
 663 }
 664
 665 void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
 666 {
 667     wxCHECK_RET( Ok(), wxT("invalid dc") );
 668
 669     wxCoord x2 = (x+w);
 670     wxCoord y2 = (y+h);
 671
 672     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 673     if ( m_brush.GetStyle() != wxTRANSPARENT )
 674     {
 675         if (!m_brushSelected) SelectBrush();
 676         MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
 677         m_MGLDC->fillEllipseArc(rect, (int)sa, (int)ea);
 678     }
 679
 680     if ( m_pen.GetStyle() != wxTRANSPARENT )
 681     {
 682         if ( !m_penSelected )
 683             SelectPen();
 684         MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,
 685                      XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
 686         m_MGLDC->ellipseArc(rect, (int)sa, (int)ea);
 687     }
 688
 689     CalcBoundingBox(x, y);
 690     CalcBoundingBox(x2, y2);
 691 }
 692
 693 void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
 694 {
 695     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 696     DrawAnyText(text, x, y);
 697
 698     // update the bounding box
 699     wxCoord w, h;
 700     CalcBoundingBox(x, y);
 701     GetTextExtent(text, &w, &h);
 702     CalcBoundingBox(x + w, y + h);
 703 }
 704
 705 bool wxDC::SelectMGLFont()
 706 {
 707     if ( m_mglFont == NULL )
 708     {
 709         float scale = m_scaleY;
 710         bool antialiased = (GetDepth() > 8);
 711
 712         m_mglFont = m_font.GetMGLfont_t(scale, antialiased);
 713         wxCHECK_MSG( m_mglFont, false, wxT("invalid font") );
 714
 715         m_MGLDC->useFont(m_mglFont);
 716         wxLogTrace("mgl_font", "useFont(%p)", m_mglFont);
 717
 718 #if !wxUSE_UNICODE
 719         wxNativeEncodingInfo nativeEnc;
 720         wxFontEncoding encoding = m_font.GetEncoding();
 721         if ( !wxGetNativeFontEncoding(encoding, &nativeEnc) ||
 722              !wxTestFontEncoding(nativeEnc) )
 723         {
 724 #if wxUSE_FONTMAP
 725             if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &nativeEnc) )
 726 #endif
 727             {
 728                 nativeEnc.mglEncoding = MGL_ENCODING_ASCII;
 729             }
 730         }
 731         m_MGLDC->setTextEncoding(nativeEnc.mglEncoding);
 732 #endif
 733     }
 734     return true;
 735 }
 736
 737 void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
 738 {
 739     wxCHECK_RET( Ok(), wxT("invalid dc") );
 740
 741     SelectMGLFont();
 742
 743     // Render the text:
 744     wxCoord xx = XLOG2DEV(x);
 745     wxCoord yy = YLOG2DEV(y);
 746
 747     m_MGLDC->setLineStyle(MGL_LINE_STIPPLE);
 748     m_MGLDC->setLineStipple(0xFFFF);
 749     m_MGLDC->setPenSize(1, 1);
 750     m_MGLDC->setPenStyle(MGL_BITMAP_SOLID);
 751
 752 #if wxUSE_UNICODE
 753     const wchar_t *c_text = text.c_str();
 754 #else
 755     const char *c_text = text.c_str();
 756 #endif
 757
 758 #if 1
 759     // FIXME_MGL - this is a temporary hack in absence of proper
 760     //             implementation of solid text background in MGL. Once
 761     //             the bug in MGL is fixed, this code should be nuked
 762     //             immediately. Note that the code is not 100% correct;
 763     //             it only works with wxCOPY logical function
 764     if ( m_backgroundMode == wxSOLID )
 765     {
 766         int w = m_MGLDC->textWidth(c_text);
 767         int h = m_MGLDC->textHeight();
 768         m_MGLDC->setColor(m_MGLDC->packColorFast(m_textBackgroundColour.Red(),
 769                 m_textBackgroundColour.Green(), m_textBackgroundColour.Blue()));
 770         m_MGLDC->fillRect(xx, yy, xx+w, yy+h);
 771     }
 772 #endif
 773
 774     m_MGLDC->setColor(m_MGLDC->packColorFast(m_textForegroundColour.Red(),
 775             m_textForegroundColour.Green(), m_textForegroundColour.Blue()));
 776     m_MGLDC->setBackColor(m_MGLDC->packColorFast(m_textBackgroundColour.Red(),
 777             m_textBackgroundColour.Green(), m_textBackgroundColour.Blue()));
 778
 779     m_MGLDC->drawStr(xx, yy, c_text);
 780
 781     // Render underline:
 782     if ( m_font.GetUnderlined() )
 783     {
 784         int x1 = xx, y1 = yy;
 785         int x2 = 0 , y2 = 0;
 786         int w = m_MGLDC->textWidth(c_text);
 787         m_MGLDC->underScoreLocation(x1, y1, c_text);
 788         switch (m_MGLDC->getTextDirection())
 789         {
 790             case MGL_RIGHT_DIR: x2 = x1 + w, y2 = y1; break;
 791             case MGL_LEFT_DIR:  x2 = x1 - w, y2 = y1; break;
 792             case MGL_UP_DIR:    x2 = x1, y2 = y1 - w; break;
 793             case MGL_DOWN_DIR:  x2 = x1, y2 = y1 + w; break;
 794         }
 795         m_MGLDC->line(x1, y1, x2, y2);
 796     }
 797
 798     m_penSelected = m_brushSelected = false;
 799 }
 800
 801 void wxDC::DoDrawRotatedText(const wxString& text,
 802                              wxCoord x, wxCoord y,
 803                              double angle)
 804 {
 805     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 806
 807     if ( angle == 0 )
 808     {
 809         DoDrawText(text, x, y);
 810         return;
 811     }
 812     else if ( angle == 90.0 )
 813         m_MGLDC->setTextDirection(MGL_UP_DIR);
 814     else if ( angle == 180.0 )
 815         m_MGLDC->setTextDirection(MGL_LEFT_DIR);
 816     else if ( angle == 270.0 )
 817         m_MGLDC->setTextDirection(MGL_DOWN_DIR);
 818     else
 819     {
 820         // FIXME_MGL -- implement once MGL supports it
 821         wxFAIL_MSG(wxT("wxMGL only supports rotated text with angle 0,90,180 or 270"));
 822         return;
 823     }
 824
 825     DrawAnyText(text, x, y);
 826
 827     // Restore default:
 828     m_MGLDC->setTextDirection(MGL_RIGHT_DIR);
 829 }
 830
 831 // ---------------------------------------------------------------------------
 832 // set GDI objects
 833 // ---------------------------------------------------------------------------
 834
 835 void wxDC::SelectMGLStipplePen(int style)
 836 {
 837     ushort stipple;
 838
 839     switch (style)
 840     {
 841         case wxDOT:        stipple = STIPPLE_wxDOT;        break;
 842         case wxLONG_DASH:  stipple = STIPPLE_wxLONG_DASH;  break;
 843         case wxSHORT_DASH: stipple = STIPPLE_wxSHORT_DASH; break;
 844         case wxDOT_DASH:   stipple = STIPPLE_wxDOT_DASH;   break;
 845         default:           stipple = STIPPLE_wxSOLID;      break;
 846     }
 847
 848     m_MGLDC->setLineStyle(MGL_LINE_STIPPLE);
 849     m_MGLDC->setLineStipple(stipple);
 850     m_MGLDC->setPenSize(1, 1);
 851     m_MGLDC->setPenStyle(MGL_BITMAP_SOLID);
 852     m_penOfsY = m_penOfsX = 0;
 853 }
 854
 855 // Accepted valus of SelectMGLFatPen's 2nd argument
 856 enum {
 857     wxMGL_SELECT_FROM_PEN,
 858     wxMGL_SELECT_FROM_BRUSH
 859 };
 860
 861 void wxDC::SelectMGLFatPen(int style, int flag)
 862 {
 863     MGL_penStyleType penstyle;
 864     const pattern_t *pattern = NULL;
 865     pixpattern24_t *pixPattern = NULL;
 866     int wx, wy;
 867     int slot;
 868
 869     // Since MGL pens may be created from wxBrush or wxPen and we often
 870     // switch between pens and brushes, we take advantage of MGL's ability
 871     // to have multiple (pix)pattern_t's loaded. We always download pen
 872     // to 0th slot and brush to 1st slot.
 873     if ( flag == wxMGL_SELECT_FROM_PEN )
 874         slot = 0;
 875     else
 876         slot = 1;
 877
 878     // compute pen's width:
 879     if ( m_pen.GetWidth() <= 1 )
 880     {
 881         wx = wy = 1;
 882         m_penOfsX = m_penOfsY = 0;
 883     }
 884     else
 885     {
 886         wx = (int)(0.5 + fabs((double) XLOG2DEVREL(m_pen.GetWidth())));
 887         wy = (int)(0.5 + fabs((double) YLOG2DEVREL(m_pen.GetWidth())));
 888         m_penOfsX = -wx/2;
 889         m_penOfsY = -wy/2;
 890     }
 891
 892     // find pen's type:
 893     penstyle = MGL_BITMAP_TRANSPARENT;
 894     switch (style)
 895     {
 896         case wxBDIAGONAL_HATCH:  pattern = &PATTERN_wxBDIAGONAL_HATCH;
 897                                  penstyle = MGL_BITMAP_TRANSPARENT;
 898                                  break;
 899         case wxCROSSDIAG_HATCH:  pattern = &PATTERN_wxCROSSDIAG_HATCH;
 900                                  penstyle = MGL_BITMAP_TRANSPARENT;
 901                                  break;
 902         case wxFDIAGONAL_HATCH:  pattern = &PATTERN_wxFDIAGONAL_HATCH;
 903                                  penstyle = MGL_BITMAP_TRANSPARENT;
 904                                  break;
 905         case wxCROSS_HATCH:      pattern = &PATTERN_wxCROSS_HATCH;
 906                                  penstyle = MGL_BITMAP_TRANSPARENT;
 907                                  break;
 908         case wxHORIZONTAL_HATCH: pattern = &PATTERN_wxHORIZONTAL_HATCH;
 909                                  penstyle = MGL_BITMAP_TRANSPARENT;
 910                                  break;
 911         case wxVERTICAL_HATCH:   pattern = &PATTERN_wxVERTICAL_HATCH;
 912                                  penstyle = MGL_BITMAP_TRANSPARENT;
 913                                  break;
 914
 915         case wxSTIPPLE:
 916             if ( flag == wxMGL_SELECT_FROM_PEN )
 917                 pixPattern = (pixpattern24_t*) m_pen.GetPixPattern();
 918             else
 919                 pixPattern = (pixpattern24_t*) m_brush.GetPixPattern();
 920             penstyle = MGL_PIXMAP;
 921             break;
 922
 923         case wxSTIPPLE_MASK_OPAQUE:
 924             pattern = (pattern_t*) m_brush.GetMaskPattern();
 925             penstyle = MGL_BITMAP_OPAQUE;
 926             break;
 927
 928         case wxSOLID:
 929         default:
 930             penstyle = MGL_BITMAP_SOLID; break;
 931     }
 932
 933     // ...and finally, pass the pen to MGL:
 934
 935     if ( pattern )
 936     {
 937         if ( !m_downloadedPatterns[slot] )
 938         {
 939             m_MGLDC->setPenBitmapPattern(slot, pattern);
 940             m_downloadedPatterns[slot] = true;
 941         }
 942         m_MGLDC->usePenBitmapPattern(slot);
 943     }
 944
 945     if ( pixPattern )
 946     {
 947         if ( !m_downloadedPatterns[slot] )
 948         {
 949             pixpattern_t pix;
 950             int x, y, c;
 951
 952             switch (GetDepth())
 953             {
 954                 case 8:
 955                     for (y = 0; y < 8; y++)
 956                         for (x = 0; x < 8; x++)
 957                             pix.b8.p[x][y] = (uchar)m_MGLDC->packColorFast(
 958                                                         pixPattern->p[x][y][0],
 959                                                         pixPattern->p[x][y][1],
 960                                                         pixPattern->p[x][y][2]);
 961                     break;
 962                 case 15:
 963                 case 16:
 964                     for (y = 0; y < 8; y++)
 965                         for (x = 0; x < 8; x++)
 966                             pix.b16.p[x][y] = (M_uint16)m_MGLDC->packColorFast(
 967                                                         pixPattern->p[x][y][0],
 968                                                         pixPattern->p[x][y][1],
 969                                                         pixPattern->p[x][y][2]);
 970                     break;
 971                 case 24:
 972                     for (y = 0; y < 8; y++)
 973                         for (x = 0; x < 8; x++)
 974                             for (c = 0; c < 3; c++)
 975                                 pix.b24.p[x][y][c] = pixPattern->p[x][y][c];
 976                     break;
 977                 case 32:
 978                     for (y = 0; y < 8; y++)
 979                         for (x = 0; x < 8; x++)
 980                             pix.b32.p[x][y] = m_MGLDC->packColorFast(
 981                                                         pixPattern->p[x][y][0],
 982                                                         pixPattern->p[x][y][1],
 983                                                         pixPattern->p[x][y][2]);
 984                     break;
 985                 default:
 986                     wxFAIL_MSG(wxT("invalid DC depth"));
 987                     break;
 988             }
 989             m_MGLDC->setPenPixmapPattern(slot, &pix);
 990             m_downloadedPatterns[slot] = true;
 991         }
 992         m_MGLDC->usePenPixmapPattern(slot);
 993     }
 994
 995     m_MGLDC->setLineStyle(MGL_LINE_PENSTYLE);
 996     m_MGLDC->setPenStyle(penstyle);
 997     m_MGLDC->setPenSize(wy, wx);
 998 }
 999
1000 void wxDC::SelectPen()
1001 {
1002     wxCHECK_RET( Ok(), wxT("invalid dc") );
1003
1004     wxColour& clr = m_pen.GetColour();
1005     m_MGLDC->makeCurrent(); // will go away with MGL6.0
1006     m_MGLDC->setColorRGB(clr.Red(), clr.Green(), clr.Blue());
1007
1008     switch (m_pen.GetStyle())
1009     {
1010         case wxTRANSPARENT:
1011             break;
1012
1013         case wxDOT:
1014         case wxLONG_DASH:
1015         case wxSHORT_DASH:
1016         case wxDOT_DASH:
1017             SelectMGLStipplePen(m_pen.GetStyle());
1018             break;
1019
1020         case wxBDIAGONAL_HATCH:
1021         case wxCROSSDIAG_HATCH:
1022         case wxFDIAGONAL_HATCH:
1023         case wxCROSS_HATCH:
1024         case wxHORIZONTAL_HATCH:
1025         case wxVERTICAL_HATCH:
1026             SelectMGLFatPen(m_pen.GetStyle(), wxMGL_SELECT_FROM_PEN);
1027             break;
1028
1029         case wxSTIPPLE:
1030             SelectMGLFatPen(m_pen.GetStyle(), wxMGL_SELECT_FROM_PEN);
1031             break;
1032
1033         case wxSOLID:
1034         case wxUSER_DASH:
1035         default:
1036             if ( m_pen.GetWidth() <= 1 )
1037                 SelectMGLStipplePen(wxSOLID);
1038             else
1039                 SelectMGLFatPen(wxSOLID, wxMGL_SELECT_FROM_PEN);
1040             break;
1041     }
1042     m_penSelected = true;
1043     m_brushSelected = false;
1044 }
1045
1046 void wxDC::SelectBrush()
1047 {
1048     wxCHECK_RET( Ok(), wxT("invalid dc") );
1049
1050     wxColour fg, bg;
1051     m_MGLDC->makeCurrent(); // will go away with MGL6.0
1052
1053     if ( m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
1054     {
1055         fg = m_textForegroundColour;
1056         bg = m_textBackgroundColour;
1057     }
1058     else
1059     {
1060         fg = m_brush.GetColour();
1061         bg = m_backgroundBrush.GetColour();
1062     }
1063
1064     m_MGLDC->setColorRGB(fg.Red(), fg.Green(), fg.Blue());
1065     m_MGLDC->setBackColor(m_MGLDC->packColorFast(bg.Red(), bg.Green(), bg.Blue()));
1066     m_penSelected = false;
1067     m_brushSelected = true;
1068
1069     SelectMGLFatPen(m_brush.GetStyle(), wxMGL_SELECT_FROM_BRUSH);
1070 }
1071
1072 void wxDC::SetPen(const wxPen& pen)
1073 {
1074     if ( !pen.Ok() ) return;
1075     if ( m_pen == pen ) return;
1076     m_pen = pen;
1077     m_penSelected = false;
1078     m_downloadedPatterns[0] = false;
1079 }
1080
1081 void wxDC::SetBrush(const wxBrush& brush)
1082 {
1083     if ( !brush.Ok() ) return;
1084     if ( m_brush == brush ) return;
1085     m_brush = brush;
1086     m_brushSelected = false;
1087     m_downloadedPatterns[1] = false;
1088 }
1089
1090 void wxDC::SetPalette(const wxPalette& palette)
1091 {
1092     wxCHECK_RET( Ok(), wxT("invalid dc") );
1093
1094     if ( !palette.Ok() )
1095     {
1096         if ( m_oldPalette.Ok() )
1097             SetPalette(m_oldPalette);
1098         return;
1099     }
1100
1101     if ( palette.IsSameAs(m_palette) )
1102         return;
1103
1104     m_oldPalette = m_palette;
1105     m_palette = palette;
1106
1107     int cnt = m_palette.GetColoursCount();
1108     palette_t *pal = m_palette.GetMGLpalette_t();
1109     m_MGLDC->setPalette(pal, cnt, 0);
1110     m_MGLDC->realizePalette(cnt, 0, TRUE);
1111 }
1112
1113 void wxDC::SetFont(const wxFont& font)
1114 {
1115     if ( font.Ok() )
1116     {
1117         m_font = font;
1118         m_mglFont = NULL;
1119     }
1120 }
1121
1122 void wxDC::SetBackground(const wxBrush& brush)
1123 {
1124     wxCHECK_RET( Ok(), wxT("invalid dc") );
1125
1126     if (!brush.Ok()) return;
1127
1128     m_backgroundBrush = brush;
1129     wxColour &clr = m_backgroundBrush.GetColour();
1130     m_MGLDC->makeCurrent(); // will go away with MGL6.0
1131     m_MGLDC->setBackColor(
1132              m_MGLDC->packColorFast(clr.Red(), clr.Green(), clr.Blue()));
1133 }
1134
1135 void wxDC::SetBackgroundMode(int mode)
1136 {
1137     m_backgroundMode = mode;
1138     if ( mode == wxSOLID )
1139         m_MGLDC->setBackMode(MGL_OPAQUE_BACKGROUND);
1140     else
1141         m_MGLDC->setBackMode(MGL_TRANSPARENT_BACKGROUND);
1142 }
1143
1144 void wxDC::SetLogicalFunction(wxRasterOperationMode function)
1145 {
1146     wxCHECK_RET( Ok(), wxT("invalid dc") );
1147
1148     m_logicalFunction = function;
1149
1150     m_MGLDC->makeCurrent(); // will go away with MGL6.0
1151     m_MGLDC->setWriteMode(LogicalFunctionToMGLRop(m_logicalFunction));
1152 }
1153
1154 int wxDC::LogicalFunctionToMGLRop(int logFunc) const
1155 {
1156     MGL_writeModeType rop;
1157
1158     switch (logFunc)
1159     {
1160         case wxCLEAR:        rop = MGL_R2_BLACK;         break;
1161         case wxXOR:          rop = MGL_R2_XORSRC;        break;
1162         case wxINVERT:       rop = MGL_R2_NOT;           break;
1163         case wxOR_REVERSE:   rop = MGL_R2_MERGESRCNOT;   break;
1164         case wxAND_REVERSE:  rop = MGL_R2_MASKSRCNOT;    break;
1165         case wxCOPY:         rop = MGL_R2_COPYSRC;       break;
1166         case wxAND:          rop = MGL_R2_MASKSRC;       break;
1167         case wxAND_INVERT:   rop = MGL_R2_MASKNOTSRC;    break;
1168         case wxNO_OP:        rop = MGL_R2_NOP;           break;
1169         case wxNOR:          rop = MGL_R2_NOTMERGESRC;   break;
1170         case wxEQUIV:        rop = MGL_R2_NOTXORSRC;     break;
1171         case wxSRC_INVERT:   rop = MGL_R2_NOTCOPYSRC;    break;
1172         case wxOR_INVERT:    rop = MGL_R2_MERGENOTSRC;   break;
1173         case wxNAND:         rop = MGL_R2_NOTMASKSRC;    break;
1174         case wxOR:           rop = MGL_R2_MERGESRC;      break;
1175         case wxSET:          rop = MGL_R2_WHITE;         break;
1176         default:
1177            wxFAIL_MSG( wxT("unsupported logical function") );
1178            return MGL_REPLACE_MODE;
1179     }
1180     return (int)rop;
1181 }
1182
1183 bool wxDC::StartDoc(const wxString& WXUNUSED(message))
1184 {
1185     // We might be previewing, so return true to let it continue.
1186     return true;
1187 }
1188
1189 void wxDC::EndDoc()
1190 {
1191 }
1192
1193 void wxDC::StartPage()
1194 {
1195 }
1196
1197 void wxDC::EndPage()
1198 {
1199 }
1200
1201 // ---------------------------------------------------------------------------
1202 // text metrics
1203 // ---------------------------------------------------------------------------
1204
1205 wxCoord wxDC::GetCharHeight() const
1206 {
1207     wxCurrentDCSwitcher switcher(m_MGLDC);
1208     if ( !wxConstCast(this, wxDC)->SelectMGLFont() ) return -1;
1209     return YDEV2LOGREL(m_mglFont->fontHeight);
1210 }
1211
1212 wxCoord wxDC::GetCharWidth() const
1213 {
1214     wxCurrentDCSwitcher switcher(m_MGLDC);
1215     if ( !wxConstCast(this, wxDC)->SelectMGLFont() ) return -1;
1216     // VS: wxT() is intentional, charWidth() has both char and wchar_t version
1217     // VS: YDEV is corrent, it should *not* be XDEV, because font's are only
1218     //     scaled according to m_scaleY
1219     return YDEV2LOGREL(m_mglFont->fontWidth);
1220 }
1221
1222 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
1223                            wxCoord *descent, wxCoord *externalLeading,
1224                            const wxFont *theFont) const
1225 {
1226     wxFont oldFont;
1227
1228     if ( theFont != NULL )
1229     {
1230         oldFont = m_font;
1231         wxConstCast(this, wxDC)->SetFont(*theFont);
1232     }
1233
1234     wxCurrentDCSwitcher switcher(m_MGLDC);
1235     if ( !wxConstCast(this, wxDC)->SelectMGLFont() ) return;
1236
1237     if ( x )
1238         // VS: YDEV is corrent, it should *not* be XDEV, because font's are
1239         //     only scaled according to m_scaleY
1240         *x = YDEV2LOGREL(m_MGLDC->textWidth(string.wc_str()));
1241     if ( y )
1242         *y = YDEV2LOGREL(m_MGLDC->textHeight());
1243     if ( descent )
1244         *descent = YDEV2LOGREL(m_mglFont->descent);
1245     if ( externalLeading )
1246         *externalLeading = YDEV2LOGREL(m_mglFont->leading);
1247
1248     if ( theFont != NULL )
1249         wxConstCast(this, wxDC)->SetFont(oldFont);
1250 }
1251
1252
1253 // ---------------------------------------------------------------------------
1254 // mapping modes
1255 // ---------------------------------------------------------------------------
1256
1257 void wxDC::ComputeScaleAndOrigin()
1258 {
1259     double newX = m_logicalScaleX * m_userScaleX;
1260     double newY = m_logicalScaleY * m_userScaleY;
1261
1262     // make sure font will be reloaded before drawing:
1263     if ( newY != m_scaleY )
1264         m_mglFont = NULL;
1265     // make sure m_penOfs{X,Y} will be reevaluated before drawing:
1266     if ( newY != m_scaleY || newX != m_scaleX )
1267         m_penSelected = false;
1268
1269     m_scaleX = newX, m_scaleY = newY;
1270 }
1271
1272 void wxDC::DoGetSize(int *w, int *h) const
1273 {
1274     if (w) *w = m_MGLDC->sizex()+1;
1275     if (h) *h = m_MGLDC->sizey()+1;
1276 }
1277
1278 void wxDC::DoGetSizeMM(int *width, int *height) const
1279 {
1280     int w = 0;
1281     int h = 0;
1282     GetSize(&w, &h);
1283     if ( width ) *width = int(double(w) / (m_userScaleX*m_mm_to_pix_x));
1284     if ( height ) *height = int(double(h) / (m_userScaleY*m_mm_to_pix_y));
1285 }
1286
1287 wxSize wxDC::GetPPI() const
1288 {
1289     return wxSize(int(double(m_mm_to_pix_x) * inches2mm),
1290                   int(double(m_mm_to_pix_y) * inches2mm));
1291 }
1292
1293
1294 // ---------------------------------------------------------------------------
1295 // Blitting
1296 // ---------------------------------------------------------------------------
1297
1298 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
1299                   wxCoord width, wxCoord height,
1300                   wxDC *source, wxCoord xsrc, wxCoord ysrc,
1301                   wxRasterOperationMode rop, bool useMask,
1302                   wxCoord xsrcMask, wxCoord ysrcMask)
1303 {
1304     wxCHECK_MSG( Ok(), false, wxT("invalid dc") );
1305     wxCHECK_MSG( source, false, wxT("invalid source dc") );
1306
1307     // transform the source DC coords to the device ones
1308     xsrc = source->LogicalToDeviceX(xsrc);
1309     ysrc = source->LogicalToDeviceY(ysrc);
1310
1311     /* FIXME_MGL: use the mask origin when drawing transparently */
1312     if (xsrcMask == -1 && ysrcMask == -1)
1313     {
1314         xsrcMask = xsrc; ysrcMask = ysrc;
1315     }
1316     else
1317     {
1318         xsrcMask = source->LogicalToDeviceX(xsrcMask);
1319         ysrcMask = source->LogicalToDeviceY(ysrcMask);
1320     }
1321
1322     CalcBoundingBox(xdest, ydest);
1323     CalcBoundingBox(xdest + width, ydest + height);
1324
1325     /* scale/translate size and position */
1326     wxCoord xx = XLOG2DEV(xdest);
1327     wxCoord yy = YLOG2DEV(ydest);
1328
1329     if ( source->m_isMemDC )
1330     {
1331         wxMemoryDC *memDC = (wxMemoryDC*) source;
1332         DoDrawSubBitmap(memDC->GetSelectedObject(),
1333                         xsrc, ysrc, width, height,
1334                         xdest, ydest, rop, useMask);
1335     }
1336     else
1337     {
1338         wxCoord ww = XLOG2DEVREL(width);
1339         wxCoord hh = YLOG2DEVREL(height);
1340
1341         m_MGLDC->makeCurrent(); // will go away with MGL6.0
1342         m_MGLDC->bitBlt(*source->GetMGLDC(),
1343                         xsrc, ysrc, xsrc + ww, ysrc + hh,
1344                         xx, yy, LogicalFunctionToMGLRop(rop));
1345     }
1346
1347     return true;
1348 }
1349
1350 void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
1351 {
1352     wxCHECK_RET( Ok(), wxT("invalid dc") );
1353     wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
1354
1355     wxCoord w = bmp.GetWidth();
1356     wxCoord h = bmp.GetHeight();
1357
1358     DoDrawSubBitmap(bmp, 0, 0, w, h, x, y, m_logicalFunction, useMask);
1359 }
1360
1361 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
1362 {
1363     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
1364     DoDrawBitmap((const wxBitmap&)icon, x, y, true);
1365 }
1366
1367
1368 static inline void DoBitBlt(const wxBitmap& src, MGLDevCtx *dst,
1369                             int sx, int sy, int sw, int sh,
1370                             int dx, int dy, int dw, int dh,
1371                             int rop, bool useStretching, bool putSection)
1372 {
1373     bitmap_t *bmp = src.GetMGLbitmap_t();
1374     if (!useStretching)
1375     {
1376         if (!putSection)
1377             dst->putBitmap(dx, dy, bmp, rop);
1378         else
1379             dst->putBitmapSection(sx, sy, sx + sw, sy + sh, dx, dy, bmp, rop);
1380     }
1381     else
1382     {
1383         if (!putSection)
1384             dst->stretchBitmap(dx, dy, dx + dw, dy + dh, bmp, rop);
1385         else
1386             dst->stretchBitmapSection(sx, sy, sx + sw, sy + sh,
1387                                       dx, dy, dx + dw, dy + dh, bmp, rop);
1388     }
1389 }
1390
1391 void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
1392                            wxCoord x, wxCoord y, wxCoord w, wxCoord h,
1393                            wxCoord destx, wxCoord desty, int rop, bool useMask)
1394 {
1395     wxCHECK_RET( Ok(), wxT("invalid dc") );
1396     wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
1397
1398     CalcBoundingBox(x, y);
1399     CalcBoundingBox(x + w, y + h);
1400
1401     wxCoord dx = XLOG2DEV(destx);
1402     wxCoord dy = YLOG2DEV(desty);
1403     wxCoord dw = XLOG2DEVREL(w);
1404     wxCoord dh = YLOG2DEVREL(h);
1405
1406     m_MGLDC->makeCurrent(); // will go away with MGL6.0
1407
1408     bool useStretching = ((w != dw) || (h != dh));
1409     bool putSection = (w != bmp.GetWidth() || h != bmp.GetHeight());
1410     MGL_writeModeType mglRop = (MGL_writeModeType)LogicalFunctionToMGLRop(rop);
1411
1412     if ( bmp.GetDepth() == 1 )
1413     {
1414         // Mono bitmaps are handled in special way -- all 1s are drawn in
1415         // foreground colours, all 0s in background colour.
1416
1417         ((wxBitmap&)bmp).SetMonoPalette(m_textForegroundColour, m_textBackgroundColour);
1418     }
1419
1420     if ( useMask && bmp.GetMask() )
1421     {
1422         // Since MGL does not support masks directly (in MGL, mask is handled
1423         // in same way as in wxImage, i.e. there is one "key" color), we
1424         // simulate masked bitblt in 6 steps (same as in MSW):
1425         //
1426         // 1. Create a temporary bitmap and copy the destination area into it.
1427         // 2. Copy the source area into the temporary bitmap using the
1428         //    specified logical function.
1429         // 3. Set the masked area in the temporary bitmap to BLACK by ANDing
1430         //    the mask bitmap with the temp bitmap with the foreground colour
1431         //    set to WHITE and the bg colour set to BLACK.
1432         // 4. Set the unmasked area in the destination area to BLACK by
1433         //    ANDing the mask bitmap with the destination area with the
1434         //    foreground colour set to BLACK and the background colour set
1435         //    to WHITE.
1436         // 5. OR the temporary bitmap with the destination area.
1437         // 6. Delete the temporary bitmap.
1438         //
1439         // This sequence of operations ensures that the source's transparent
1440         // area need not be black, and logical functions are supported.
1441
1442         wxBitmap mask = bmp.GetMask()->GetBitmap();
1443
1444         MGLMemoryDC *temp;
1445
1446         if ( GetDepth() <= 8 )
1447         {
1448             temp = new MGLMemoryDC(dw, dh, GetDepth(), NULL);
1449             wxDC tempdc;
1450             tempdc.SetMGLDC(temp, false);
1451             tempdc.SetPalette(m_palette);
1452         }
1453         else
1454         {
1455             pixel_format_t pf;
1456             m_MGLDC->getPixelFormat(pf);
1457             temp = new MGLMemoryDC(dw, dh, GetDepth(), &pf);
1458         }
1459
1460         wxCHECK_RET( temp->isValid(), wxT("cannot create temporary dc") );
1461
1462         temp->bitBlt(*m_MGLDC, dx, dy, dx + dw, dy + dh, 0, 0, MGL_REPLACE_MODE);
1463
1464         DoBitBlt(bmp, temp, x, y, w, h, 0, 0, dw, dh, mglRop,
1465                  useStretching, putSection);
1466
1467         mask.SetMonoPalette(wxColour(0,0,0), wxColour(255,255,255));
1468         DoBitBlt(mask, temp, x, y, w, h, 0, 0, dw, dh, MGL_R2_MASKSRC,
1469                  useStretching, putSection);
1470         DoBitBlt(mask, m_MGLDC, x, y, w, h, dx, dy, dw, dh, MGL_R2_MASKNOTSRC,
1471                  useStretching, putSection);
1472
1473         m_MGLDC->bitBlt(*temp, 0, 0, dw, dh, dx, dy, MGL_OR_MODE);
1474
1475         delete temp;
1476     }
1477
1478     else
1479     {
1480         DoBitBlt(bmp, m_MGLDC, x, y, w, h, dx, dy, dw, dh, mglRop,
1481                  useStretching, putSection);
1482     }
1483 }