src/os2/dc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dc.cpp
   3 // Purpose:     wxDC class
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     10/14/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/window.h"
  17     #include "wx/dc.h"
  18     #include "wx/utils.h"
  19     #include "wx/dialog.h"
  20     #include "wx/app.h"
  21     #include "wx/bitmap.h"
  22     #include "wx/dcmemory.h"
  23     #include "wx/log.h"
  24     #include "wx/icon.h"
  25 #endif
  26
  27 #include "wx/dcprint.h"
  28
  29 #include <string.h>
  30 #include <math.h>
  31
  32 #include "wx/os2/private.h"
  33
  34     IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
  35
  36 // ---------------------------------------------------------------------------
  37 // constants
  38 // ---------------------------------------------------------------------------
  39
  40 static const int VIEWPORT_EXTENT = 1000;
  41
  42 static const int MM_POINTS = 9;
  43 static const int MM_METRIC = 10;
  44
  45 // usually this is defined in math.h
  46 #ifndef M_PI
  47     static const double M_PI = 3.14159265358979323846;
  48 #endif // M_PI
  49
  50 // ---------------------------------------------------------------------------
  51 // private functions
  52 // ---------------------------------------------------------------------------
  53
  54 // convert degrees to radians
  55 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  56
  57 int SetTextColor(
  58   HPS                               hPS
  59 , int                               nForegroundColour
  60 )
  61 {
  62     CHARBUNDLE                      vCbnd;
  63
  64     vCbnd.lColor =  nForegroundColour;
  65     ::GpiSetAttrs( hPS       // presentation-space handle
  66                   ,PRIM_CHAR // Char primitive.
  67                   ,CBB_COLOR // sets color.
  68                   ,0         //
  69                   ,&vCbnd    // buffer for attributes.
  70                  );
  71     return 0;
  72 }
  73
  74 int QueryTextBkColor(
  75   HPS                               hPS
  76 )
  77 {
  78     CHARBUNDLE                      vCbnd;
  79
  80     ::GpiQueryAttrs( hPS            // presentation-space handle
  81                     ,PRIM_CHAR      // Char primitive.
  82                     ,CBB_BACK_COLOR // Background color.
  83                     ,&vCbnd         // buffer for attributes.
  84                    );
  85     return vCbnd.lBackColor;
  86 }
  87
  88
  89 int SetTextBkColor(
  90   HPS                               hPS
  91 , int                               nBackgroundColour
  92 )
  93 {
  94     CHARBUNDLE                      vCbnd;
  95     int                             rc;
  96
  97     rc =  QueryTextBkColor(hPS);
  98
  99     vCbnd.lBackColor = nBackgroundColour;
 100     ::GpiSetAttrs(hPS,            // presentation-space handle
 101                   PRIM_CHAR,      // Char primitive.
 102                   CBB_BACK_COLOR, // sets color.
 103                   0,
 104                   &vCbnd          // buffer for attributes.
 105                  );
 106     return rc;
 107 }
 108
 109 int SetBkMode(
 110   HPS                               hPS
 111 , int                               nBackgroundMode
 112 )
 113 {
 114     if(nBackgroundMode == wxTRANSPARENT)
 115         ::GpiSetBackMix( hPS
 116                         ,BM_LEAVEALONE
 117                        );
 118     else
 119         // the background of the primitive takes  over whatever is underneath.
 120         ::GpiSetBackMix( hPS
 121                         ,BM_OVERPAINT
 122                         );
 123     return 0;
 124 }
 125
 126 // ===========================================================================
 127 // implementation
 128 // ===========================================================================
 129
 130 // ---------------------------------------------------------------------------
 131 // wxDC
 132 // ---------------------------------------------------------------------------
 133
 134 wxDC::wxDC(void)
 135 {
 136     m_pCanvas      = NULL;
 137
 138     m_hOldBitmap   = 0;
 139     m_hOldPen      = 0;
 140     m_hOldBrush    = 0;
 141     m_hOldFont     = 0;
 142     m_hOldPalette  = 0;
 143
 144     m_bOwnsDC      = FALSE;
 145     m_hDC          = 0;
 146     m_nDCCount     = 0;
 147     m_hOldPS       = NULL;
 148     m_hPS          = NULL;
 149     m_bIsPaintTime = FALSE; // True at Paint Time
 150     m_brush.GetColour().Set("WHITE");
 151 }
 152
 153 wxDC::~wxDC(void)
 154 {
 155 }
 156
 157 // This will select current objects out of the DC,
 158 // which is what you have to do before deleting the
 159 // DC.
 160 void wxDC::SelectOldObjects(WXHDC dc)
 161 {
 162     if (dc)
 163     {
 164         if (m_hOldBitmap)
 165         {
 166 //            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
 167             if (m_vSelectedBitmap.Ok())
 168             {
 169                 m_vSelectedBitmap.SetSelectedInto(NULL);
 170             }
 171         }
 172         m_hOldBitmap = 0;
 173         if (m_hOldPen)
 174         {
 175 //            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
 176         }
 177         m_hOldPen = 0;
 178         if (m_hOldBrush)
 179         {
 180 //            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
 181         }
 182         m_hOldBrush = 0;
 183         if (m_hOldFont)
 184         {
 185 //            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
 186         }
 187         m_hOldFont = 0;
 188         if (m_hOldPalette)
 189         {
 190 //            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
 191         }
 192         m_hOldPalette = 0;
 193     }
 194
 195     m_brush           = wxNullBrush;
 196     m_pen             = wxNullPen;
 197     m_palette         = wxNullPalette;
 198     m_font            = wxNullFont;
 199     m_backgroundBrush = wxNullBrush;
 200     m_vSelectedBitmap = wxNullBitmap;
 201 }
 202
 203 // ---------------------------------------------------------------------------
 204 // clipping
 205 // ---------------------------------------------------------------------------
 206
 207 #define DO_SET_CLIPPING_BOX()                    \
 208 {                                                \
 209     RECTL rect;                                  \
 210                                                  \
 211     ::GpiQueryClipBox(m_hPS, &rect);             \
 212                                                  \
 213     m_clipX1 = (wxCoord) XDEV2LOG(rect.xLeft);   \
 214     m_clipY1 = (wxCoord) YDEV2LOG(rect.yTop);    \
 215     m_clipX2 = (wxCoord) XDEV2LOG(rect.xRight);  \
 216     m_clipY2 = (wxCoord) YDEV2LOG(rect.yBottom); \
 217 }
 218
 219 void wxDC::DoSetClippingRegion(
 220   wxCoord                           x
 221 , wxCoord                           y
 222 , wxCoord                           width
 223 , wxCoord                           height
 224 )
 225 {
 226     RECTL                           vRect;
 227
 228     m_clipping    = TRUE;
 229     vRect.xLeft   = XLOG2DEV(x);
 230     vRect.yTop    = YLOG2DEV(m_vRclPaint.yTop - y);
 231     vRect.xRight  = XLOG2DEV(x + width);
 232     vRect.yBottom = YLOG2DEV(m_vRclPaint.yTop - (y + height));
 233     ::GpiIntersectClipRectangle(m_hPS, &vRect);
 234     DO_SET_CLIPPING_BOX()
 235 } // end of wxDC::DoSetClippingRegion
 236
 237 void wxDC::DoSetClippingRegionAsRegion(
 238   const wxRegion&                   rRegion
 239 )
 240 {
 241      wxCHECK_RET(rRegion.GetHRGN(), wxT("invalid clipping region"));
 242      HRGN                           hRgnOld;
 243
 244      m_clipping = TRUE;
 245      ::GpiSetClipRegion( m_hPS
 246                         ,(HRGN)rRegion.GetHRGN()
 247                         ,&hRgnOld
 248                        );
 249     DO_SET_CLIPPING_BOX()
 250 } // end of wxDC::DoSetClippingRegionAsRegion
 251
 252 void wxDC::DestroyClippingRegion(void)
 253 {
 254     if (m_clipping && m_hPS)
 255     {
 256          HRGN                       hRgnOld;
 257          RECTL                      vRect;
 258
 259          // TODO: this should restore the previous clipped region
 260          //       so that OnPaint processing works correctly, and
 261          //       the update doesn't get destroyed after the first
 262          //       DestroyClippingRegion
 263          vRect.xLeft   = XLOG2DEV(0);
 264          vRect.yTop    = YLOG2DEV(32000);
 265          vRect.xRight  = XLOG2DEV(32000);
 266          vRect.yBottom = YLOG2DEV(0);
 267
 268          HRGN                       hRgn = ::GpiCreateRegion(m_hPS, 1, &vRect);
 269
 270          ::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
 271      }
 272       m_clipping = FALSE;
 273 } // end of wxDC::DestroyClippingRegion
 274
 275 // ---------------------------------------------------------------------------
 276 // query capabilities
 277 // ---------------------------------------------------------------------------
 278
 279 bool wxDC::CanDrawBitmap() const
 280 {
 281     return TRUE;
 282 }
 283
 284 bool wxDC::CanGetTextExtent() const
 285 {
 286     // What sort of display is it?
 287     int technology = 0; // TODO:  ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
 288
 289     // TODO: return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
 290     return FALSE;
 291 }
 292
 293 int wxDC::GetDepth() const
 294 {
 295    // TODO:
 296    return (1);
 297 }
 298
 299 // ---------------------------------------------------------------------------
 300 // drawing
 301 // ---------------------------------------------------------------------------
 302
 303 void wxDC::Clear()
 304 {
 305     ::GpiErase(m_hPS);
 306 }
 307
 308 void wxDC::DoFloodFill(
 309   wxCoord                           vX
 310 , wxCoord                           vY
 311 , const wxColour&                   rCol
 312 , int                               nStyle
 313 )
 314 {
 315     POINTL                          vPtlPos;
 316     LONG                            lColor;
 317     LONG                            lOptions;
 318
 319     vPtlPos.x = vX;             // Loads x-coordinate
 320     vPtlPos.y = vY;             // Loads y-coordinate
 321     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 322     lColor = rCol.GetPixel();
 323     lOptions = FF_BOUNDARY;
 324     if(wxFLOOD_SURFACE == nStyle)
 325         lOptions = FF_SURFACE;
 326
 327     ::GpiFloodFill(m_hPS, lOptions, lColor);
 328 }
 329
 330 bool wxDC::DoGetPixel(
 331   wxCoord                           vX
 332 , wxCoord                           vY
 333 , wxColour*                         pCol
 334 ) const
 335 {
 336     POINTL                          vPoint;
 337     LONG                            lColor;
 338
 339     vPoint.x = vX;
 340     vPoint.y = vY;
 341     lColor = ::GpiSetPel(m_hPS, &vPoint);
 342     pCol->Set((unsigned long)lColor);
 343     if(lColor>= 0)
 344         return(TRUE);
 345     else
 346         return(FALSE);
 347 }
 348
 349 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 350 {
 351    // TODO
 352 }
 353
 354 void wxDC::DoDrawLine(
 355   wxCoord                           vX1
 356 , wxCoord                           vY1
 357 , wxCoord                           vX2
 358 , wxCoord                           vY2
 359 )
 360 {
 361     POINTL                          vPoint[2];
 362
 363     vPoint[0].x = vX1;
 364     vPoint[0].y = m_vRclPaint.yTop - vY1;
 365     vPoint[1].x = vX2;
 366     vPoint[1].y = m_vRclPaint.yTop - vY2;
 367     ::GpiMove(m_hPS, &vPoint[0]);
 368     ::GpiLine(m_hPS, &vPoint[1]);
 369 }
 370
 371 //////////////////////////////////////////////////////////////////////////////
 372 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
 373 // and ending at (x2, y2). The current pen is used for the outline and the
 374 // current brush for filling the shape. The arc is drawn in an anticlockwise
 375 // direction from the start point to the end point.
 376 //////////////////////////////////////////////////////////////////////////////
 377 void wxDC::DoDrawArc(
 378   wxCoord                           vX1
 379 , wxCoord                           vY1
 380 , wxCoord                           vX2
 381 , wxCoord                           vY2
 382 , wxCoord                           vXc
 383 , wxCoord                           vYc
 384 )
 385 {
 386      POINTL                         vPtlPos;
 387      POINTL                         vPtlArc[2]; // Structure for current position
 388      int                            nDx;
 389      int                            nDy;
 390      double                         dRadius;
 391      double                         dAngl1;
 392      double                         dAngl2;
 393      double                         dAnglmid;
 394      wxCoord                        vXm;
 395      wxCoord                        vYm;
 396      ARCPARAMS                      vArcp; // Structure for arc parameters
 397
 398     if((vX1 == vXc && vY1 == vXc) || (vX2 == vXc && vY2 == vXc))
 399         return; // Draw point ??
 400     dRadius = 0.5 * ( hypot( (double)(vY1 - vYc)
 401                             ,(double)(vX1 - vXc)
 402                            ) +
 403                       hypot( (double)(vY2 - vYc)
 404                             ,(double)(vX2 - vXc)
 405                            )
 406                      );
 407
 408     dAngl1 = atan2( (double)(vY1 - vYc)
 409                    ,(double)(vX1 - vXc)
 410                   );
 411     dAngl2 = atan2( (double)(vY2 - vYc)
 412                    ,(double)(vX2 - vXc)
 413                   );
 414     if(dAngl2 < dAngl1)
 415         dAngl2 += M_PI * 2;
 416
 417     //
 418     // GpiPointArc can't draw full arc
 419     //
 420      if(dAngl2 == dAngl1 || (vX1 == vX2 && vY1 == vY2) )
 421      {
 422         //
 423         // Medium point
 424         //
 425         dAnglmid = (dAngl1 + dAngl2)/2. + M_PI;
 426         vXm      = vXc + dRadius * cos(dAnglmid);
 427         vYm      = vYc + dRadius * sin(dAnglmid);
 428         DoDrawArc( vX1, vY1
 429                   ,vXm, vYm
 430                   ,vXc, vYc
 431                  );
 432         DoDrawArc( vXm, vYm
 433                   ,vX2, vY2
 434                   ,vXc, vYc
 435                  );
 436         return;
 437     }
 438
 439     //
 440     // Medium point
 441     //
 442     dAnglmid = (dAngl1 + dAngl2)/2.;
 443     vXm      = vXc + dRadius * cos(dAnglmid);
 444     vYm      = vYc + dRadius * sin(dAnglmid);
 445
 446     //
 447     // Ellipse main axis (r,q), (p,s) with center at (0,0) */
 448     //
 449     vArcp.lR = 0;
 450     vArcp.lQ = 1;
 451     vArcp.lP = 1;
 452     vArcp.lS = 0;
 453     ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
 454
 455     vPtlPos.x = vX1; // Loads x-coordinate
 456     vPtlPos.y = vY1; // Loads y-coordinate
 457     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 458     vPtlArc[0].x = vXm;
 459     vPtlArc[0].y = vYm;
 460     vPtlArc[1].x = vX2;
 461     vPtlArc[1].y = vY2;
 462     ::GpiPointArc(m_hPS, vPtlArc); // Draws the arc
 463 }
 464
 465 void wxDC::DoDrawCheckMark(
 466   wxCoord                           vX1
 467 , wxCoord                           vY1
 468 , wxCoord                           vWidth
 469 , wxCoord                           vHeight
 470 )
 471 {
 472     POINTL                          vPoint[2];
 473
 474     vPoint[0].x = vX1;
 475     vPoint[0].y = vY1;
 476     vPoint[1].x = vX1 + vWidth;
 477     vPoint[1].y = vY1 + vHeight;
 478
 479     ::GpiMove(m_hPS, &vPoint[0]);
 480     ::GpiBox( m_hPS       // handle to a presentation space
 481              ,DRO_OUTLINE // draw the box outline ? or ?
 482              ,&vPoint[1]  // address of the corner
 483              ,0L          // horizontal corner radius
 484              ,0L          // vertical corner radius
 485             );
 486     if(vWidth > 4 && vHeight > 4)
 487     {
 488         int                         nTmp;
 489
 490         vPoint[0].x += 2; vPoint[0].y += 2;
 491         vPoint[1].x -= 2; vPoint[1].y -= 2;
 492         ::GpiMove(m_hPS, &vPoint[0]);
 493         ::GpiLine(m_hPS, &vPoint[1]);
 494         nTmp = vPoint[0].x;
 495         vPoint[0].x = vPoint[1].x;
 496         vPoint[1].x = nTmp;
 497         ::GpiMove(m_hPS, &vPoint[0]);
 498         ::GpiLine(m_hPS, &vPoint[1]);
 499     }
 500 }
 501
 502 void wxDC::DoDrawPoint(
 503   wxCoord                           vX
 504 , wxCoord                           vY
 505 )
 506 {
 507     POINTL                          vPoint;
 508
 509     vPoint.x = vX;
 510     vPoint.y = m_vRclPaint.yTop - vY;
 511     ::GpiSetPel(m_hPS, &vPoint);
 512 }
 513
 514 void wxDC::DoDrawPolygon(
 515   int                               n
 516 , wxPoint                           vPoints[]
 517 , wxCoord                           vXoffset
 518 , wxCoord                           vYoffset
 519 , int                               nFillStyle
 520 )
 521 {
 522     ULONG                           ulCount = 1;    // Number of polygons.
 523     POLYGON                         vPlgn;          // polygon.
 524     ULONG                           flOptions = 0L; // Drawing options.
 525
 526 //////////////////////////////////////////////////////////////////////////////
 527 // This contains fields of option bits... to draw boundary lines as well as
 528 // the area interior.
 529 //
 530 // Drawing boundary lines:
 531 //   POLYGON_NOBOUNDARY              Does not draw boundary lines.
 532 //   POLYGON_BOUNDARY                Draws boundary lines (the default).
 533 //
 534 // Construction of the area interior:
 535 //   POLYGON_ALTERNATE               Constructs interior in alternate mode
 536 //                                   (the default).
 537 //   POLYGON_WINDING                 Constructs interior in winding mode.
 538 //////////////////////////////////////////////////////////////////////////////
 539
 540     ULONG                           flModel = 0L; // Drawing model.
 541
 542 //////////////////////////////////////////////////////////////////////////////
 543 // Drawing model.
 544 //   POLYGON_INCL  Fill is inclusive of bottom right (the default).
 545 //   POLYGON_EXCL  Fill is exclusive of bottom right.
 546 //       This is provided to aid migration from other graphics models.
 547 //////////////////////////////////////////////////////////////////////////////
 548
 549     LONG                            lHits = 0L; // Correlation/error indicator.
 550     POINTL                          vPoint;
 551     int                             i;
 552     int                             nIsTRANSPARENT = 0;
 553     LONG                            lBorderColor = 0L;
 554     LONG                            lColor = 0L;
 555
 556     lBorderColor = m_pen.GetColour().GetPixel();
 557     lColor       = m_brush.GetColour().GetPixel();
 558     if(m_brush.GetStyle() == wxTRANSPARENT)
 559         nIsTRANSPARENT = 1;
 560
 561     vPlgn.ulPoints = n;
 562     vPlgn.aPointl = (POINTL*) calloc( n + 1
 563                                      ,sizeof(POINTL)
 564                                     ); // well, new will call malloc
 565
 566     for(i = 0; i < n; i++)
 567     {
 568         vPlgn.aPointl[i].x = vPoints[i].x; // +xoffset;
 569         vPlgn.aPointl[i].y = vPoints[i].y; // +yoffset;
 570     }
 571     flModel = POLYGON_BOUNDARY;
 572     if(nFillStyle == wxWINDING_RULE)
 573         flModel |= POLYGON_WINDING;
 574     else
 575         flModel |= POLYGON_ALTERNATE;
 576
 577     vPoint.x = vXoffset;
 578     vPoint.y = vYoffset;
 579
 580     ::GpiSetColor(m_hPS, lBorderColor);
 581     ::GpiMove(m_hPS, &vPoint);
 582     lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
 583     free(vPlgn.aPointl);
 584 }
 585
 586 void wxDC::DoDrawLines(
 587   int                               n
 588 , wxPoint                           vPoints[]
 589 , wxCoord                           vXoffset
 590 , wxCoord                           vYoffset
 591 )
 592 {
 593     int                             i;
 594     POINTL                          vPoint;
 595
 596     vPoint.x = vPoints[0].x + vXoffset;
 597     vPoint.y = vPoints[0].y + vYoffset;
 598     ::GpiMove(m_hPS, &vPoint);
 599
 600     LONG                            lBorderColor = m_pen.GetColour().GetPixel();
 601
 602     ::GpiSetColor(m_hPS, lBorderColor);
 603     for(i = 1; i < n; i++)
 604     {
 605         vPoint.x = vPoints[0].x + vXoffset;
 606         vPoint.y = vPoints[0].y + vYoffset;
 607         ::GpiLine(m_hPS, &vPoint);
 608     }
 609 }
 610
 611 void wxDC::DoDrawRectangle(
 612   wxCoord                           vX
 613 , wxCoord                           vY
 614 , wxCoord                           vWidth
 615 , wxCoord                           vHeight
 616 )
 617 {
 618     POINTL                          vPoint[2];
 619     LONG                            lControl;
 620     LONG                            lColor;
 621     LONG                            lBorderColor;
 622     int                             nIsTRANSPARENT = 0;
 623
 624     vPoint[0].x = vX;
 625     vPoint[0].y = m_vRclPaint.yTop - (vY + vHeight);
 626     vPoint[1].x = vX + vWidth;
 627     vPoint[1].y = m_vRclPaint.yTop - vY;
 628     ::GpiMove(m_hPS, &vPoint[0]);
 629     lColor       = m_brush.GetColour().GetPixel();
 630     lBorderColor = m_pen.GetColour().GetPixel();
 631     if (m_brush.GetStyle() == wxTRANSPARENT)
 632         nIsTRANSPARENT = 1;
 633     if(lColor == lBorderColor || nIsTRANSPARENT)
 634     {
 635         lControl = DRO_OUTLINEFILL; //DRO_FILL;
 636         if(m_brush.GetStyle() == wxTRANSPARENT)
 637             lControl = DRO_OUTLINE;
 638
 639         ::GpiSetColor(m_hPS, lColor);
 640         ::GpiBox( m_hPS       // handle to a presentation space
 641                  ,lControl   // draw the box outline ? or ?
 642                  ,&vPoint[1]  // address of the corner
 643                  ,0L          // horizontal corner radius
 644                  ,0L          // vertical corner radius
 645                 );
 646     }
 647     else
 648     {
 649         lControl = DRO_OUTLINE;
 650         ::GpiSetColor( m_hPS
 651                       ,lBorderColor
 652                      );
 653         ::GpiBox( m_hPS
 654                  ,lControl
 655                  ,&vPoint[1]
 656                  ,0L
 657                  ,0L
 658                 );
 659         lControl = DRO_FILL;
 660         ::GpiSetColor( m_hPS
 661                       ,lColor
 662                      );
 663         vPoint[0].x = vX + 1;
 664         vPoint[0].y = m_vRclPaint.yTop - (vY + vHeight) + 1;
 665         vPoint[1].x = vX + vWidth - 2;
 666         vPoint[1].y = m_vRclPaint.yTop - (vY + 2);
 667         ::GpiMove(m_hPS, &vPoint[0]);
 668         ::GpiBox( m_hPS
 669                  ,lControl
 670                  ,&vPoint[1]
 671                  ,0L
 672                  ,0L
 673                 );
 674     }
 675 }
 676
 677 void wxDC::DoDrawRoundedRectangle(
 678   wxCoord                           vX
 679 , wxCoord                           vY
 680 , wxCoord                           vWidth
 681 , wxCoord                           vHeight
 682 , double                            dRadius
 683 )
 684 {
 685     POINTL                          vPoint[2];
 686     LONG                            lControl;
 687
 688     vPoint[0].x = vX;
 689     vPoint[0].y = YLOG2DEV(vY) - vHeight;
 690     vPoint[1].x = vX + vWidth;
 691     vPoint[1].y = vY;
 692     ::GpiMove(m_hPS, &vPoint[0]);
 693
 694     lControl = DRO_OUTLINEFILL; //DRO_FILL;
 695     if (m_brush.GetStyle() == wxTRANSPARENT)
 696         lControl = DRO_OUTLINE;
 697     ::GpiBox( m_hPS         // handle to a presentation space
 698              ,DRO_OUTLINE   // draw the box outline ? or ?
 699              ,&vPoint[1]    // address of the corner
 700              ,(LONG)dRadius // horizontal corner radius
 701              ,(LONG)dRadius // vertical corner radius
 702             );
 703 }
 704
 705 // Draw Ellipse within box (x,y) - (x+width, y+height)
 706 void wxDC::DoDrawEllipse(
 707   wxCoord                           vX
 708 , wxCoord                           vY
 709 , wxCoord                           vWidth
 710 , wxCoord                           vHeight
 711 )
 712 {
 713     POINTL                          vPtlPos; // Structure for current position
 714     FIXED                           vFxMult; // Multiplier for ellipse
 715     ARCPARAMS                       vArcp;   // Structure for arc parameters
 716
 717     vArcp.lR = 0;
 718     vArcp.lQ = vHeight/2;
 719     vArcp.lP = vWidth/2;
 720     vArcp.lS = 0;
 721     ::GpiSetArcParams( m_hPS
 722                       ,&vArcp
 723                      ); // Sets parameters to default
 724     vPtlPos.x = vX + vWidth/2;  // Loads x-coordinate
 725     vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
 726     ::GpiMove( m_hPS
 727               ,&vPtlPos
 728              ); // Sets current position
 729     vFxMult = MAKEFIXED(1, 0);             /* Sets multiplier            */
 730
 731     //
 732     // DRO_FILL, DRO_OTLINEFILL - where to get
 733     //
 734     ::GpiFullArc( m_hPS
 735                  ,DRO_OUTLINE
 736                  ,vFxMult
 737                 ); // Draws full arc with center at current position
 738 }
 739
 740 void wxDC::DoDrawEllipticArc(
 741   wxCoord                           vX
 742 , wxCoord                           vY
 743 , wxCoord                           vWidth
 744 , wxCoord                           vHeight
 745 , double                            dSa
 746 , double                            dEa
 747 )
 748 {
 749     POINTL                          vPtlPos; // Structure for current position
 750     FIXED                           vFxMult; // Multiplier for ellipse
 751     ARCPARAMS                       vArcp;   // Structure for arc parameters
 752     FIXED                           vFSa;
 753     FIXED                           vFSweepa; // Start angle, sweep angle
 754     double                          dIntPart;
 755     double                          dFractPart;
 756     double                          dRadius;
 757
 758     dFractPart = modf(dSa,&dIntPart);
 759     vFSa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
 760     dFractPart = modf(dEa - dSa, &dIntPart);
 761     vFSweepa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
 762
 763     //
 764     // Ellipse main axis (r,q), (p,s) with center at (0,0)
 765     //
 766     vArcp.lR = 0;
 767     vArcp.lQ = vHeight/2;
 768     vArcp.lP = vWidth/2;
 769     vArcp.lS = 0;
 770     ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
 771     vPtlPos.x = vX + vWidth/2  * (1. + cos(DegToRad(dSa))); // Loads x-coordinate
 772     vPtlPos.y = vY + vHeight/2 * (1. + sin(DegToRad(dSa))); // Loads y-coordinate
 773     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 774
 775     //
 776     // May be not to the center ?
 777     //
 778     vPtlPos.x = vX + vWidth/2 ; // Loads x-coordinate
 779     vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
 780     vFxMult = MAKEFIXED(1, 0);  // Sets multiplier
 781
 782     //
 783     // DRO_FILL, DRO_OTLINEFILL - where to get
 784     //
 785     ::GpiPartialArc( m_hPS
 786                     ,&vPtlPos
 787                     ,vFxMult
 788                     ,vFSa
 789                     ,vFSweepa
 790                    );
 791 }
 792
 793 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 794 {
 795     // TODO:
 796 }
 797
 798 void wxDC::DoDrawBitmap( const wxBitmap &bmp
 799                         ,wxCoord x, wxCoord y
 800                         ,bool useMask
 801                        )
 802 {
 803    // TODO
 804 }
 805
 806 void wxDC::DoDrawText(
 807   const wxString&                   rsText
 808 , wxCoord                           vX
 809 , wxCoord                           vY
 810 )
 811 {
 812     DrawAnyText( rsText
 813                 ,vX
 814                 ,vY
 815                );
 816 }
 817
 818 void wxDC::DrawAnyText(
 819   const wxString&                   rsText
 820 , wxCoord                           vX
 821 , wxCoord                           vY
 822 )
 823 {
 824     int                             nOldBackground = 0;
 825     POINTL                          vPtlStart;
 826     LONG                            lHits;
 827
 828     //
 829     // prepare for drawing the text
 830     //
 831
 832     //
 833     // Set text color attributes
 834     //
 835     if (m_textForegroundColour.Ok())
 836     {
 837         SetTextColor( m_hPS
 838                      ,(int)m_textForegroundColour.GetPixel()
 839                     );
 840     }
 841
 842     if (m_textBackgroundColour.Ok())
 843     {
 844         nOldBackground = SetTextBkColor( m_hPS
 845                                         ,(int)m_textBackgroundColour.GetPixel()
 846                                        );
 847     }
 848     SetBkMode( m_hPS
 849               ,m_backgroundMode
 850              );
 851     vPtlStart.x = vX;
 852     vPtlStart.y = vY;
 853
 854     lHits = ::GpiCharStringAt( m_hPS
 855                               ,&vPtlStart
 856                               ,rsText.length()
 857                               ,(PCH)rsText.c_str()
 858                              );
 859     if (lHits != GPI_OK)
 860     {
 861         wxLogLastError(wxT("TextOut"));
 862     }
 863
 864     //
 865     // Restore the old parameters (text foreground colour may be left because
 866     // it never is set to anything else, but background should remain
 867     // transparent even if we just drew an opaque string)
 868     //
 869     if (m_textBackgroundColour.Ok())
 870             SetTextBkColor( m_hPS
 871                            ,nOldBackground
 872                           );
 873     SetBkMode( m_hPS
 874               ,wxTRANSPARENT
 875              );
 876 }
 877
 878 void wxDC::DoDrawRotatedText(
 879   const wxString&                   rsText
 880 , wxCoord                           vX
 881 , wxCoord                           vY
 882 , double                            dAngle
 883 )
 884 {
 885     if (dAngle == 0.0)
 886     {
 887         DoDrawText( rsText
 888                    ,vX
 889                    ,vY
 890                   );
 891     }
 892
 893    // TODO:
 894    /*
 895     if ( angle == 0.0 )
 896     {
 897         DoDrawText(text, x, y);
 898     }
 899     else
 900     {
 901         LOGFONT lf;
 902         wxFillLogFont(&lf, &m_font);
 903
 904         // GDI wants the angle in tenth of degree
 905         long angle10 = (long)(angle * 10);
 906         lf.lfEscapement = angle10;
 907         lf. lfOrientation = angle10;
 908
 909         HFONT hfont = ::CreateFontIndirect(&lf);
 910         if ( !hfont )
 911         {
 912             wxLogLastError("CreateFont");
 913         }
 914         else
 915         {
 916             HFONT hfontOld = ::SelectObject(GetHdc(), hfont);
 917
 918             DrawAnyText(text, x, y);
 919
 920             (void)::SelectObject(GetHdc(), hfontOld);
 921         }
 922
 923         // call the bounding box by adding all four vertices of the rectangle
 924         // containing the text to it (simpler and probably not slower than
 925         // determining which of them is really topmost/leftmost/...)
 926         wxCoord w, h;
 927         GetTextExtent(text, &w, &h);
 928
 929         double rad = DegToRad(angle);
 930
 931         // "upper left" and "upper right"
 932         CalcBoundingBox(x, y);
 933         CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
 934         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
 935
 936         // "bottom left" and "bottom right"
 937         x += (wxCoord)(h*sin(rad));
 938         y += (wxCoord)(h*cos(rad));
 939         CalcBoundingBox(x, y);
 940         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
 941     }
 942 */
 943 }
 944
 945 // ---------------------------------------------------------------------------
 946 // set GDI objects
 947 // ---------------------------------------------------------------------------
 948
 949 void wxDC::SetPalette(const wxPalette& palette)
 950 {
 951    // TODO
 952 }
 953
 954 void wxDC::SetFont(
 955   const wxFont&                     rFont
 956 )
 957 {
 958     //
 959     // Set the old object temporarily, in case the assignment deletes an object
 960     // that's not yet selected out.
 961     //
 962     if (m_hOldFont)
 963     {
 964         m_hOldFont = 0;
 965     }
 966     m_font = rFont;
 967     if (!rFont.Ok())
 968     {
 969         m_hOldFont = 0;
 970     }
 971
 972     m_font.SetPS(m_hPS); // this will realize the font
 973
 974     if (m_font.Ok())
 975     {
 976         HFONT                       hFont = m_font.GetResourceHandle();
 977         if (hFont == (HFONT) NULL)
 978         {
 979             wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
 980         }
 981         if (!m_hOldFont)
 982             m_hOldFont = (WXHFONT) hFont;
 983     }
 984 } // end of wxDC::SetFont
 985
 986 void wxDC::SetPen(
 987   const wxPen&                      rPen
 988 )
 989 {
 990     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 991
 992     if (m_pen == rPen)
 993         return;
 994     m_pen = rPen;
 995     if (!m_pen.Ok())
 996         return;
 997
 998     if (m_hOldPen)
 999         m_hOldPen = 0L;
1000     m_pen = rPen;
1001
1002     if (!m_pen.Ok())
1003     {
1004         if (m_hOldPen)
1005         {
1006             m_pen.SetPS((HPS)m_hOldPen);
1007         }
1008         m_hOldPen = 0L;
1009     }
1010
1011     if (m_pen.Ok())
1012     {
1013         if (m_pen.GetResourceHandle())
1014         {
1015             m_pen.SetPS(m_hPS);
1016             if (!m_hOldPen)
1017                 m_hOldPen = m_pen.GetPS();
1018         }
1019     }
1020 }
1021
1022 void wxDC::SetBrush(
1023   const wxBrush&                    rBrush
1024 )
1025 {
1026     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1027
1028     if (m_brush == rBrush)
1029         return;
1030     m_brush = rBrush;
1031     if (!m_brush.Ok())
1032         return;
1033
1034     if (m_hOldBrush)
1035         m_hOldBrush = 0L;
1036     m_brush = rBrush;
1037
1038     if (!m_brush.Ok())
1039     {
1040         if (m_hOldBrush)
1041         {
1042             m_brush.SetPS((HPS)m_hOldBrush);
1043         }
1044         m_hOldBrush = 0L;
1045     }
1046
1047     if (m_brush.Ok())
1048     {
1049         if (m_brush.GetResourceHandle())
1050         {
1051             m_brush.SetPS(m_hPS);
1052             if (!m_hOldBrush)
1053                 m_hOldBrush = m_brush.GetPS();
1054         }
1055     }
1056 } // end of wxDC::SetBrush
1057
1058 void wxDC::SetBackground(const wxBrush& brush)
1059 {
1060    // TODO
1061 }
1062
1063 void wxDC::SetBackgroundMode(
1064   int                               nMode
1065 )
1066 {
1067     m_backgroundMode = nMode;
1068 }
1069
1070 void wxDC::SetLogicalFunction(int function)
1071 {
1072    // TODO
1073 }
1074
1075 void wxDC::SetRop(WXHDC dc)
1076 {
1077     if (!dc || m_logicalFunction < 0)
1078         return;
1079
1080     int c_rop;
1081     // These may be wrong
1082     switch (m_logicalFunction)
1083     {
1084 // TODO: Figure this stuff out
1085         //    case wxXOR: c_rop = R2_XORPEN; break;
1086 //    case wxXOR: c_rop = R2_NOTXORPEN; break;
1087 //    case wxINVERT: c_rop = R2_NOT; break;
1088 //    case wxOR_REVERSE: c_rop = R2_MERGEPENNOT; break;
1089 //    case wxAND_REVERSE: c_rop = R2_MASKPENNOT; break;
1090 //    case wxCLEAR: c_rop = R2_WHITE; break;
1091 //    case wxSET: c_rop = R2_BLACK; break;
1092 //    case wxSRC_INVERT: c_rop = R2_NOTCOPYPEN; break;
1093 //    case wxOR_INVERT: c_rop = R2_MERGENOTPEN; break;
1094 //    case wxAND: c_rop = R2_MASKPEN; break;
1095 //    case wxOR: c_rop = R2_MERGEPEN; break;
1096 //    case wxAND_INVERT: c_rop = R2_MASKNOTPEN; break;
1097 //    case wxEQUIV:
1098 //    case wxNAND:
1099 //    case wxCOPY:
1100     default:
1101 //      c_rop = R2_COPYPEN;
1102         break;
1103     }
1104 //    SetROP2((HDC) dc, c_rop);
1105 }
1106
1107 bool wxDC::StartDoc(const wxString& message)
1108 {
1109     // We might be previewing, so return TRUE to let it continue.
1110     return TRUE;
1111 }
1112
1113 void wxDC::EndDoc()
1114 {
1115 }
1116
1117 void wxDC::StartPage()
1118 {
1119 }
1120
1121 void wxDC::EndPage()
1122 {
1123 }
1124
1125 // ---------------------------------------------------------------------------
1126 // text metrics
1127 // ---------------------------------------------------------------------------
1128
1129 wxCoord wxDC::GetCharHeight() const
1130 {
1131     FONTMETRICS                     vFM; // metrics structure
1132
1133     ::GpiQueryFontMetrics( m_hPS
1134                           ,sizeof(FONTMETRICS)
1135                           ,&vFM
1136                          );
1137     return YDEV2LOGREL(vFM.lXHeight);
1138 }
1139
1140 wxCoord wxDC::GetCharWidth() const
1141 {
1142     FONTMETRICS                     vFM; // metrics structure
1143
1144     ::GpiQueryFontMetrics( m_hPS
1145                           ,sizeof(FONTMETRICS)
1146                           ,&vFM
1147                          );
1148     return XDEV2LOGREL(vFM.lAveCharWidth);
1149 }
1150
1151 void wxDC::DoGetTextExtent(
1152   const wxString&                   rsString
1153 , wxCoord*                          pvX
1154 , wxCoord*                          pvY
1155 , wxCoord*                          pvDescent
1156 , wxCoord*                          pvExternalLeading
1157 , wxFont*                           pTheFont
1158 ) const
1159 {
1160     POINTL                          avPoint[TXTBOX_COUNT];
1161     POINTL                          vPtMin;
1162     POINTL                          vPtMax;
1163     int                             i;
1164     int                             l;
1165     FONTMETRICS                     vFM; // metrics structure
1166     BOOL                            bRc;
1167     char*                           pStr;
1168     ERRORID                         vErrorCode; // last error id code
1169     wxFont*                         pFontToUse = (wxFont*)pTheFont;
1170
1171     char                            zMsg[128]; // DEBUG
1172     wxString                        sError;
1173
1174     if (!pFontToUse)
1175         pFontToUse = (wxFont*)&m_font;
1176     l = rsString.length();
1177     pStr = (PCH) rsString.c_str();
1178
1179     //
1180     // In world coordinates.
1181     //
1182     bRc = ::GpiQueryTextBox( m_hPS
1183                             ,l
1184                             ,pStr
1185                             ,TXTBOX_COUNT // return maximum information
1186                             ,avPoint      // array of coordinates points
1187                            );
1188     if(!bRc)
1189     {
1190        vErrorCode = ::WinGetLastError(wxGetInstance());
1191        sError = wxPMErrorToStr(vErrorCode);
1192        // DEBUG
1193        sprintf(zMsg, "GpiQueryTextBox for %s: failed with Error: %x - %s", pStr, vErrorCode, sError.c_str());
1194        (void)wxMessageBox( "wxWindows Menu sample"
1195                           ,zMsg
1196                           ,wxICON_INFORMATION
1197                          );
1198     }
1199
1200     vPtMin.x = avPoint[0].x;
1201     vPtMax.x = avPoint[0].x;
1202     vPtMin.y = avPoint[0].y;
1203     vPtMax.y = avPoint[0].y;
1204     for (i = 1; i < 4; i++)
1205     {
1206         if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
1207         if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
1208         if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
1209         if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
1210     }
1211     ::GpiQueryFontMetrics( m_hPS
1212                           ,sizeof(FONTMETRICS)
1213                           ,&vFM
1214                          );
1215
1216     if (pvX)
1217         *pvX = (wxCoord)(vPtMax.x - vPtMin.x + 1);
1218     if (pvY)
1219         *pvY = (wxCoord)(vPtMax.y - vPtMin.y + 1);
1220     if (pvDescent)
1221         *pvDescent = vFM.lMaxDescender;
1222     if (pvExternalLeading)
1223         *pvExternalLeading = vFM.lExternalLeading;
1224 }
1225
1226 void wxDC::SetMapMode( int mode )
1227 {
1228     // TODO:
1229 };
1230
1231 void wxDC::SetUserScale(double x, double y)
1232 {
1233     m_userScaleX = x;
1234     m_userScaleY = y;
1235
1236     SetMapMode(m_mappingMode);
1237 }
1238
1239 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
1240 {
1241     m_signX = xLeftRight ? 1 : -1;
1242     m_signY = yBottomUp ? -1 : 1;
1243
1244     SetMapMode(m_mappingMode);
1245 }
1246
1247 void wxDC::SetSystemScale(double x, double y)
1248 {
1249     m_scaleX = x;
1250     m_scaleY = y;
1251
1252     SetMapMode(m_mappingMode);
1253 }
1254
1255 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
1256 {
1257     // TODO:
1258 };
1259
1260 void wxDC::SetDeviceOrigin(
1261   wxCoord                           x
1262 , wxCoord                           y
1263 )
1264 {
1265     RECTL                           vRect;
1266
1267     m_deviceOriginX = x;
1268     m_deviceOriginY = y;
1269     ::GpiQueryPageViewport( m_hPS
1270                            ,&vRect
1271                           );
1272     vRect.xLeft += x;
1273     vRect.xRight += x;
1274     vRect.yBottom -= y;
1275     vRect.yTop -= y;
1276     ::GpiSetPageViewport( m_hPS
1277                          ,&vRect
1278                         );
1279 };
1280
1281 // ---------------------------------------------------------------------------
1282 // coordinates transformations
1283 // ---------------------------------------------------------------------------
1284
1285 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1286 {
1287     return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
1288 }
1289
1290 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1291 {
1292     return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX));
1293 }
1294
1295 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1296 {
1297     return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
1298 }
1299
1300 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
1301 {
1302     return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY));
1303 }
1304
1305 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
1306 {
1307     return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
1308 }
1309
1310 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
1311 {
1312     return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX);
1313 }
1314
1315 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
1316 {
1317     return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
1318 }
1319
1320 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
1321 {
1322     return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY);
1323 }
1324
1325 // ---------------------------------------------------------------------------
1326 // bit blit
1327 // ---------------------------------------------------------------------------
1328
1329 bool wxDC::DoBlit(
1330   wxCoord                           vXdest
1331 , wxCoord                           vYdest
1332 , wxCoord                           vWidth
1333 , wxCoord                           vHeight
1334 , wxDC*                             pSource
1335 , wxCoord                           vXsrc
1336 , wxCoord                           vYsrc
1337 , int                               nRop
1338 , bool                              bUseMask
1339 )
1340 {
1341     wxMask*                         pMask = NULL;
1342     CHARBUNDLE                      vCbnd;
1343     COLORREF                        vOldTextColor;
1344     COLORREF                        vOldBackground = ::GpiQueryBackColor(m_hPS);
1345
1346     if (bUseMask)
1347     {
1348         const wxBitmap&             rBmp = pSource->m_vSelectedBitmap;
1349
1350         pMask = rBmp.GetMask();
1351         if (!(rBmp.Ok() && pMask && pMask->GetMaskBitmap()))
1352         {
1353             bUseMask = FALSE;
1354         }
1355     }
1356
1357     ::GpiQueryAttrs( m_hPS
1358                     ,PRIM_CHAR
1359                     ,CBB_COLOR
1360                     ,&vCbnd
1361                    );
1362     vOldTextColor = (COLORREF)vCbnd.lColor;
1363
1364     if (m_textForegroundColour.Ok())
1365     {
1366         vCbnd.lColor = (LONG)m_textForegroundColour.GetPixel();
1367         ::GpiSetAttrs( m_hPS           // presentation-space handle
1368                       ,PRIM_CHAR       // Char primitive.
1369                       ,CBB_COLOR       // sets color.
1370                       ,0
1371                       ,&vCbnd          // buffer for attributes.
1372                      );
1373     }
1374     if (m_textBackgroundColour.Ok())
1375     {
1376         ::GpiSetBackColor(m_hPS, (LONG)m_textBackgroundColour.GetPixel());
1377     }
1378
1379     LONG                            lRop = ROP_SRCCOPY;
1380
1381     switch (nRop)
1382     {
1383         case wxXOR:          lRop = ROP_SRCINVERT;        break;
1384         case wxINVERT:       lRop = ROP_DSTINVERT;        break;
1385         case wxOR_REVERSE:   lRop = 0x00DD0228;           break;
1386         case wxAND_REVERSE:  lRop = ROP_SRCERASE;         break;
1387         case wxCLEAR:        lRop = ROP_ZERO;             break;
1388         case wxSET:          lRop = ROP_ONE;              break;
1389         case wxOR_INVERT:    lRop = ROP_MERGEPAINT;       break;
1390         case wxAND:          lRop = ROP_SRCAND;           break;
1391         case wxOR:           lRop = ROP_SRCPAINT;         break;
1392         case wxEQUIV:        lRop = 0x00990066;           break;
1393         case wxNAND:         lRop = 0x007700E6;           break;
1394         case wxAND_INVERT:   lRop = 0x00220326;           break;
1395         case wxCOPY:         lRop = ROP_SRCCOPY;          break;
1396         case wxNO_OP:        lRop = ROP_NOTSRCERASE;      break;
1397         case wxSRC_INVERT:   lRop = ROP_SRCINVERT;        break;
1398         case wxNOR:          lRop = ROP_NOTSRCCOPY;       break;
1399         default:
1400            wxFAIL_MSG( wxT("unsupported logical function") );
1401            return FALSE;
1402     }
1403
1404     bool                            bSuccess;
1405
1406     if (bUseMask)
1407     {
1408         //
1409         // Blit bitmap with mask
1410         //
1411
1412         //
1413         // Create a temp buffer bitmap and DCs/PSs to access it and the mask
1414         //
1415         HDC                             hDCMask;
1416         HDC                             hDCBuffer;
1417         HPS                             hPSMask;
1418         HPS                             hPSBuffer;
1419         DEVOPENSTRUC                    vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1420         BITMAPINFOHEADER2               vBmpHdr;
1421         SIZEL                           vSize = {0, 0};
1422         LONG                            rc;
1423
1424         hDCMask = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
1425         hDCBuffer = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
1426         hPSMask = ::GpiCreatePS(vHabmain, hDCMask, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
1427         hPSBuffer = ::GpiCreatePS(vHabmain, hDCBuffer, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
1428
1429         memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
1430         vBmpHdr.cbFix     = sizeof(BITMAPINFOHEADER2);
1431         vBmpHdr.cx        = vWidth;
1432         vBmpHdr.cy        = vHeight;
1433         vBmpHdr.cPlanes   = 1;
1434         vBmpHdr.cBitCount = 24;
1435
1436         HBITMAP                         hBufBitmap = ::GpiCreateBitmap(GetHPS(), &vBmpHdr, 0L, NULL, NULL);
1437         POINTL                          aPoint1[4] = { 0, 0
1438                                                       ,vWidth, vHeight
1439                                                       ,vXdest, vYdest
1440                                                       ,vXdest + vWidth, vYdest + vHeight
1441                                                      };
1442         POINTL                          aPoint2[4] = { 0, 0
1443                                                       ,vWidth, vHeight
1444                                                       ,vXsrc, vYsrc
1445                                                       ,vXsrc + vWidth, vYsrc + vHeight
1446                                                      };
1447         POINTL                          aPoint3[4] = { vXdest, vYdest
1448                                                       ,vXdest + vWidth, vYdest + vHeight
1449                                                       ,vXsrc, vYsrc
1450                                                       ,vXsrc + vWidth, vYsrc + vHeight
1451                                                      };
1452         POINTL                          aPoint4[4] = { vXdest, vYdest
1453                                                       ,vXdest + vWidth, vYdest + vHeight
1454                                                       ,0, 0
1455                                                       ,vWidth, vHeight
1456                                                      };
1457         ::GpiSetBitmap(hPSMask, (HBITMAP) pMask->GetMaskBitmap());
1458         ::GpiSetBitmap(hPSBuffer, (HBITMAP) hBufBitmap);
1459
1460         //
1461         // Copy dest to buffer
1462         //
1463         rc = ::GpiBitBlt( hPSBuffer
1464                          ,GetHPS()
1465                          ,4L
1466                          ,aPoint1
1467                          ,ROP_SRCCOPY
1468                          ,BBO_IGNORE
1469                         );
1470         if (rc == GPI_ERROR)
1471         {
1472             wxLogLastError(wxT("BitBlt"));
1473         }
1474
1475         //
1476         // Copy src to buffer using selected raster op
1477         //
1478         rc = ::GpiBitBlt( hPSBuffer
1479                          ,GetHPS()
1480                          ,4L
1481                          ,aPoint2
1482                          ,lRop
1483                          ,BBO_IGNORE
1484                         );
1485         if (rc == GPI_ERROR)
1486         {
1487             wxLogLastError(wxT("BitBlt"));
1488         }
1489
1490         //
1491         // Set masked area in buffer to BLACK (pixel value 0)
1492         //
1493         COLORREF                        vPrevBkCol = ::GpiQueryBackColor(GetHPS());
1494         COLORREF                        vPrevCol = ::GpiQueryColor(GetHPS());
1495
1496         ::GpiSetBackColor(GetHPS(), OS2RGB(255, 255, 255));
1497         ::GpiSetColor(GetHPS(), OS2RGB(0, 0, 0));
1498
1499         rc = ::GpiBitBlt( hPSBuffer
1500                          ,hPSMask
1501                          ,4L
1502                          ,aPoint2
1503                          ,ROP_SRCAND
1504                          ,BBO_IGNORE
1505                         );
1506         if (rc == GPI_ERROR)
1507         {
1508             wxLogLastError(wxT("BitBlt"));
1509         }
1510
1511         //
1512         // Set unmasked area in dest to BLACK
1513         //
1514         ::GpiSetBackColor(GetHPS(), OS2RGB(0, 0, 0));
1515         ::GpiSetColor(GetHPS(), OS2RGB(255, 255, 255));
1516         rc = ::GpiBitBlt( GetHPS()
1517                          ,hPSMask
1518                          ,4L
1519                          ,aPoint3
1520                          ,ROP_SRCAND
1521                          ,BBO_IGNORE
1522                         );
1523         if (rc == GPI_ERROR)
1524         {
1525             wxLogLastError(wxT("BitBlt"));
1526         }
1527
1528         //
1529         // Restore colours to original values
1530         //
1531         ::GpiSetBackColor(GetHPS(), vPrevBkCol);
1532         ::GpiSetColor(GetHPS(), vPrevCol);
1533
1534         //
1535         // OR buffer to dest
1536         //
1537         rc = ::GpiBitBlt( GetHPS()
1538                          ,hPSMask
1539                          ,4L
1540                          ,aPoint4
1541                          ,ROP_SRCPAINT
1542                          ,BBO_IGNORE
1543                         );
1544         if (rc == GPI_ERROR)
1545         {
1546             bSuccess = FALSE;
1547             wxLogLastError(wxT("BitBlt"));
1548         }
1549
1550         //
1551         // Tidy up temporary DCs and bitmap
1552         //
1553         ::GpiSetBitmap(hPSMask, NULLHANDLE);
1554         ::GpiSetBitmap(hPSBuffer, NULLHANDLE);
1555         ::GpiDestroyPS(hPSMask);
1556         ::GpiDestroyPS(hPSBuffer);
1557         ::DevCloseDC(hDCMask);
1558         ::DevCloseDC(hDCBuffer);
1559         ::GpiDeleteBitmap(hBufBitmap);
1560         bSuccess = TRUE;
1561     }
1562     else // no mask, just BitBlt() it
1563     {
1564         POINTL                          aPoint[4] = { vXdest, vYdest
1565                                                      ,vXdest + vWidth, vYdest + vHeight
1566                                                      ,vXsrc, vYsrc
1567                                                      ,vXsrc + vWidth, vYsrc + vHeight
1568                                                     };
1569
1570         bSuccess = (::GpiBitBlt( m_hPS
1571                                 ,pSource->GetHPS()
1572                                 ,4L
1573                                 ,aPoint
1574                                 ,lRop
1575                                 ,BBO_IGNORE
1576                                ) != GPI_ERROR);
1577         if (!bSuccess )
1578         {
1579             wxLogLastError(wxT("BitBlt"));
1580         }
1581     }
1582     vCbnd.lColor = (LONG)vOldTextColor;
1583     ::GpiSetAttrs( m_hPS           // presentation-space handle
1584                   ,PRIM_CHAR       // Char primitive.
1585                   ,CBB_COLOR       // sets color.
1586                   ,0
1587                   ,&vCbnd          // buffer for attributes.
1588                  );
1589     ::GpiSetBackColor(m_hPS, (LONG)vOldBackground);
1590     return bSuccess;
1591 }
1592
1593 void wxDC::DoGetSize( int* width, int* height ) const
1594 {
1595     // TODO:
1596 };
1597
1598 void wxDC::DoGetSizeMM( int* width, int* height ) const
1599 {
1600     // TODO:
1601 };
1602
1603 wxSize wxDC::GetPPI() const
1604 {
1605    int x = 1;
1606    int y = 1;
1607    // TODO:
1608    return (wxSize(x,y));
1609 }
1610
1611 void wxDC::SetLogicalScale( double x, double y )
1612 {
1613     // TODO:
1614 };
1615
1616 #if WXWIN_COMPATIBILITY
1617 void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
1618                          float *descent, float *externalLeading,
1619                          wxFont *theFont, bool use16bit) const
1620 {
1621     wxCoord x1, y1, descent1, externalLeading1;
1622     GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
1623     *x = x1; *y = y1;
1624     if (descent)
1625         *descent = descent1;
1626     if (externalLeading)
1627         *externalLeading = externalLeading1;
1628 }
1629 #endif
1630