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     #include "wx/msgdlg.h"
  26     #include "wx/module.h"
  27 #endif
  28
  29 #include "wx/dcprint.h"
  30
  31 #include <string.h>
  32 #include <math.h>
  33
  34 #include "wx/os2/private.h"
  35
  36     IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
  37
  38 //
  39 // wxWindows uses the Microsoft convention that the origin is the UPPER left.
  40 // Native OS/2 however in the GPI and PM define the origin as the LOWER left.
  41 // In order to map OS/2 GPI/PM y coordinates to wxWindows coordinates we must
  42 // perform the following transformation:
  43 //
  44 // Parent object height:     POBJHEIGHT
  45 // Desried origin:           WXORIGINY
  46 // Object to place's height: OBJHEIGHT
  47 //
  48 // To get the OS2 position from the wxWindows one:
  49 //
  50 // OS2Y = POBJHEIGHT - (WXORIGINY + OBJHEIGHT)
  51 //
  52 // For OS/2 wxDC's we will always determine m_vRclPaint as the size of the
  53 // OS/2 Presentation Space associated with the device context.  y is the
  54 // desired application's y coordinate of the origin in wxWindows space.
  55 // objy is the height of the object we are going to draw.
  56 //
  57 #define OS2Y(y, objy) ((m_vRclPaint.yTop - m_vRclPaint.yBottom) - (y + objy))
  58
  59 // ---------------------------------------------------------------------------
  60 // constants
  61 // ---------------------------------------------------------------------------
  62
  63 static const int VIEWPORT_EXTENT = 1000;
  64
  65 static const int MM_POINTS = 9;
  66 static const int MM_METRIC = 10;
  67
  68 // usually this is defined in math.h
  69 #ifndef M_PI
  70     static const double M_PI = 3.14159265358979323846;
  71 #endif // M_PI
  72
  73 // ---------------------------------------------------------------------------
  74 // private functions
  75 // ---------------------------------------------------------------------------
  76
  77 // convert degrees to radians
  78 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  79
  80 int SetTextColor(
  81   HPS                               hPS
  82 , int                               nForegroundColour
  83 )
  84 {
  85     CHARBUNDLE                      vCbnd;
  86
  87     vCbnd.lColor =  nForegroundColour;
  88     ::GpiSetAttrs( hPS       // presentation-space handle
  89                   ,PRIM_CHAR // Char primitive.
  90                   ,CBB_COLOR // sets color.
  91                   ,0         //
  92                   ,&vCbnd    // buffer for attributes.
  93                  );
  94     return 0;
  95 }
  96
  97 int QueryTextBkColor(
  98   HPS                               hPS
  99 )
 100 {
 101     CHARBUNDLE                      vCbnd;
 102
 103     ::GpiQueryAttrs( hPS            // presentation-space handle
 104                     ,PRIM_CHAR      // Char primitive.
 105                     ,CBB_BACK_COLOR // Background color.
 106                     ,&vCbnd         // buffer for attributes.
 107                    );
 108     return vCbnd.lBackColor;
 109 }
 110
 111
 112 int SetTextBkColor(
 113   HPS                               hPS
 114 , int                               nBackgroundColour
 115 )
 116 {
 117     CHARBUNDLE                      vCbnd;
 118     int                             rc;
 119
 120     rc =  QueryTextBkColor(hPS);
 121
 122     vCbnd.lBackColor = nBackgroundColour;
 123     ::GpiSetAttrs(hPS,            // presentation-space handle
 124                   PRIM_CHAR,      // Char primitive.
 125                   CBB_BACK_COLOR, // sets color.
 126                   0,
 127                   &vCbnd          // buffer for attributes.
 128                  );
 129     return rc;
 130 }
 131
 132 int SetBkMode(
 133   HPS                               hPS
 134 , int                               nBackgroundMode
 135 )
 136 {
 137     if(nBackgroundMode == wxTRANSPARENT)
 138         ::GpiSetBackMix( hPS
 139                         ,BM_LEAVEALONE
 140                        );
 141     else
 142         // the background of the primitive takes  over whatever is underneath.
 143         ::GpiSetBackMix( hPS
 144                         ,BM_OVERPAINT
 145                         );
 146     return 0;
 147 }
 148
 149 // ===========================================================================
 150 // implementation
 151 // ===========================================================================
 152
 153 #if wxUSE_DC_CACHEING
 154
 155 /*
 156  * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
 157  * improve it in due course, either using arrays, or simply storing pointers to one
 158  * entry for the bitmap, and two for the DCs. -- JACS
 159  */
 160
 161 // ---------------------------------------------------------------------------
 162 // wxDCCacheEntry
 163 // ---------------------------------------------------------------------------
 164
 165 wxList wxDC::m_svBitmapCache;
 166 wxList wxDC::m_svDCCache;
 167
 168 wxDCCacheEntry::wxDCCacheEntry(
 169   WXHBITMAP                         hBitmap
 170 , int                               nWidth
 171 , int                               nHeight
 172 , int                               nDepth
 173 )
 174 {
 175     m_hBitmap = hBitmap;
 176     m_hPS     = NULLHANDLE;
 177     m_nWidth  = nWidth;
 178     m_nHeight = nHeight;
 179     m_nDepth  = nDepth;
 180 } // end of wxDCCacheEntry::wxDCCacheEntry
 181
 182 wxDCCacheEntry::wxDCCacheEntry(
 183   HPS                               hPS
 184 , int                               nDepth
 185 )
 186 {
 187     m_hBitmap = NULLHANDLE;
 188     m_hPS     = hPS;
 189     m_nWidth  = 0;
 190     m_nHeight = 0;
 191     m_nDepth  = nDepth;
 192 } // end of wxDCCacheEntry::wxDCCacheEntry
 193
 194 wxDCCacheEntry::~wxDCCacheEntry()
 195 {
 196     if (m_hBitmap)
 197         ::GpiDeleteBitmap(m_hBitmap);
 198     if (m_hPS)
 199         ::GpiDestroyPS(m_hPS);
 200 } // end of wxDCCacheEntry::~wxDCCacheEntry
 201
 202 wxDCCacheEntry* wxDC::FindBitmapInCache(
 203   HPS                               hPS
 204 , int                               nWidth
 205 , int                               nHeight
 206 )
 207 {
 208     int                             nDepth = 24; // we'll fix this later ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
 209     wxNode*                         pNode = m_svBitmapCache.First();
 210     BITMAPINFOHEADER2               vBmpHdr;
 211
 212     while(pNode)
 213     {
 214         wxDCCacheEntry*             pEntry = (wxDCCacheEntry*)pNode->Data();
 215
 216         if (pEntry->m_nDepth == nDepth)
 217         {
 218             memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
 219
 220             if (pEntry->m_nWidth < nWidth || pEntry->m_nHeight < nHeight)
 221             {
 222                 ::GpiDeleteBitmap((HBITMAP)pEntry->m_hBitmap);
 223                 vBmpHdr.cbFix     = sizeof(BITMAPINFOHEADER2);
 224                 vBmpHdr.cx        = nWidth;
 225                 vBmpHdr.cy        = nHeight;
 226                 vBmpHdr.cPlanes   = 1;
 227                 vBmpHdr.cBitCount = nDepth;
 228
 229                 pEntry->m_hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
 230                                                                   ,&vBmpHdr
 231                                                                   ,0L, NULL, NULL
 232                                                                  );
 233                 if (!pEntry->m_hBitmap)
 234                 {
 235                     wxLogLastError(wxT("CreateCompatibleBitmap"));
 236                 }
 237                 pEntry->m_nWidth  = nWidth;
 238                 pEntry->m_nHeight = nHeight;
 239                 return pEntry;
 240             }
 241             return pEntry;
 242         }
 243         pNode = pNode->Next();
 244     }
 245     memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
 246     vBmpHdr.cbFix     = sizeof(BITMAPINFOHEADER2);
 247     vBmpHdr.cx        = nWidth;
 248     vBmpHdr.cy        = nHeight;
 249     vBmpHdr.cPlanes   = 1;
 250     vBmpHdr.cBitCount = nDepth;
 251
 252     WXHBITMAP                       hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
 253                                                                             ,&vBmpHdr
 254                                                                             ,0L, NULL, NULL
 255                                                                            );
 256     if (!hBitmap)
 257     {
 258         wxLogLastError(wxT("CreateCompatibleBitmap"));
 259     }
 260     wxDCCacheEntry*                 pEntry = new wxDCCacheEntry( hBitmap
 261                                                                 ,nWidth
 262                                                                 ,nHeight
 263                                                                 ,nDepth
 264                                                                );
 265     AddToBitmapCache(pEntry);
 266     return pEntry;
 267 } // end of FindBitmapInCache
 268
 269 wxDCCacheEntry* wxDC::FindDCInCache(
 270   wxDCCacheEntry*                   pNotThis
 271 , HPS                               hPS
 272 )
 273 {
 274     int                             nDepth = 24; // we'll fix this up later ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
 275     wxNode*                         pNode = m_svDCCache.First();
 276
 277     while(pNode)
 278     {
 279         wxDCCacheEntry*             pEntry = (wxDCCacheEntry*)pNode->Data();
 280
 281         //
 282         // Don't return the same one as we already have
 283         //
 284         if (!pNotThis || (pNotThis != pEntry))
 285         {
 286             if (pEntry->m_nDepth == nDepth)
 287             {
 288                 return pEntry;
 289             }
 290         }
 291         pNode = pNode->Next();
 292     }
 293     wxDCCacheEntry*                 pEntry = new wxDCCacheEntry( hPS
 294                                                                 ,nDepth
 295                                                                );
 296     AddToDCCache(pEntry);
 297     return pEntry;
 298 } // end of wxDC::FindDCInCache
 299
 300 void wxDC::AddToBitmapCache(
 301   wxDCCacheEntry*                   pEntry
 302 )
 303 {
 304     m_svBitmapCache.Append(pEntry);
 305 } // end of wxDC::AddToBitmapCache
 306
 307 void wxDC::AddToDCCache(
 308   wxDCCacheEntry*                   pEntry
 309 )
 310 {
 311     m_svDCCache.Append(pEntry);
 312 } // end of wxDC::AddToDCCache
 313
 314 void wxDC::ClearCache()
 315 {
 316     m_svBitmapCache.DeleteContents(TRUE);
 317     m_svBitmapCache.Clear();
 318     m_svBitmapCache.DeleteContents(FALSE);
 319     m_svDCCache.DeleteContents(TRUE);
 320     m_svDCCache.Clear();
 321     m_svDCCache.DeleteContents(FALSE);
 322 } // end of wxDC::ClearCache
 323
 324 // Clean up cache at app exit
 325 class wxDCModule : public wxModule
 326 {
 327 public:
 328     virtual bool OnInit() { return TRUE; }
 329     virtual void OnExit() { wxDC::ClearCache(); }
 330
 331 private:
 332     DECLARE_DYNAMIC_CLASS(wxDCModule)
 333 }; // end of CLASS wxDCModule
 334
 335 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
 336
 337 #endif // ndef for wxUSE_DC_CACHEING
 338
 339 // ---------------------------------------------------------------------------
 340 // wxDC
 341 // ---------------------------------------------------------------------------
 342
 343 wxDC::wxDC(void)
 344 {
 345     wxColour                        vColor;
 346
 347     m_pCanvas      = NULL;
 348
 349     m_hOldBitmap   = 0;
 350     m_hOldPen      = 0;
 351     m_hOldBrush    = 0;
 352     m_hOldFont     = 0;
 353     m_hOldPalette  = 0;
 354
 355     m_bOwnsDC      = FALSE;
 356     m_hDC          = 0;
 357     m_hOldPS       = NULL;
 358     m_hPS          = NULL;
 359     m_bIsPaintTime = FALSE; // True at Paint Time
 360
 361     vColor.InitFromName("BLACK");
 362     m_pen.SetColour(vColor);
 363     vColor.Set("WHITE");
 364     m_brush.SetColour(vColor);
 365 } // end of wxDC::wxDC
 366
 367 wxDC::~wxDC(void)
 368 {
 369     if ( m_hDC != 0 )
 370     {
 371         SelectOldObjects(m_hDC);
 372
 373         // if we own the HDC, we delete it, otherwise we just release it
 374
 375         if (m_bOwnsDC)
 376         {
 377             if(m_hPS)
 378             {
 379                 ::GpiAssociate(m_hPS, NULLHANDLE);
 380                 ::GpiDestroyPS(m_hPS);
 381             }
 382             m_hPS = NULLHANDLE;
 383             ::DevCloseDC((HDC)m_hDC);
 384         }
 385         else
 386         {
 387             //
 388             // Just Dissacociate, not destroy if we don't own the DC
 389             //
 390             if(m_hPS)
 391             {
 392                 ::GpiAssociate(m_hPS, NULLHANDLE);
 393             }
 394         }
 395     }
 396 } // end of wxDC::~wxDC
 397
 398 // This will select current objects out of the DC,
 399 // which is what you have to do before deleting the
 400 // DC.
 401 void wxDC::SelectOldObjects(
 402   WXHDC                             hPS
 403 )
 404 {
 405     if (hPS)
 406     {
 407         if (m_hOldBitmap)
 408         {
 409             ::GpiSetBitmap(hPS, (HBITMAP) m_hOldBitmap);
 410             if (m_vSelectedBitmap.Ok())
 411             {
 412                 m_vSelectedBitmap.SetSelectedInto(NULL);
 413             }
 414         }
 415         m_hOldBitmap = 0;
 416         //
 417         // OS/2 has no other native GDI objects to set in a PS/DC like windows
 418         //
 419         m_hOldPen = 0;
 420         m_hOldBrush = 0;
 421         m_hOldFont = 0;
 422         m_hOldPalette = 0;
 423     }
 424
 425     m_brush           = wxNullBrush;
 426     m_pen             = wxNullPen;
 427     m_palette         = wxNullPalette;
 428     m_font            = wxNullFont;
 429     m_backgroundBrush = wxNullBrush;
 430     m_vSelectedBitmap = wxNullBitmap;
 431 } // end of wxDC::SelectOldObjects
 432
 433 // ---------------------------------------------------------------------------
 434 // clipping
 435 // ---------------------------------------------------------------------------
 436
 437 #define DO_SET_CLIPPING_BOX()                    \
 438 {                                                \
 439     RECTL rect;                                  \
 440                                                  \
 441     ::GpiQueryClipBox(m_hPS, &rect);             \
 442                                                  \
 443     m_clipX1 = (wxCoord) XDEV2LOG(rect.xLeft);   \
 444     m_clipY1 = (wxCoord) YDEV2LOG(rect.yTop);    \
 445     m_clipX2 = (wxCoord) XDEV2LOG(rect.xRight);  \
 446     m_clipY2 = (wxCoord) YDEV2LOG(rect.yBottom); \
 447 }
 448
 449 void wxDC::DoSetClippingRegion(
 450   wxCoord                           vX
 451 , wxCoord                           vY
 452 , wxCoord                           vWidth
 453 , wxCoord                           vHeight
 454 )
 455 {
 456     RECTL                           vRect;
 457
 458     vY = OS2Y(vY,vHeight);
 459     m_clipping    = TRUE;
 460     vRect.xLeft   = vX;
 461     vRect.yTop    = vY + vHeight;
 462     vRect.xRight  = vX + vWidth;
 463     vRect.yBottom = vY;
 464     ::GpiIntersectClipRectangle(m_hPS, &vRect);
 465     DO_SET_CLIPPING_BOX()
 466 } // end of wxDC::DoSetClippingRegion
 467
 468 void wxDC::DoSetClippingRegionAsRegion(
 469   const wxRegion&                   rRegion
 470 )
 471 {
 472      wxCHECK_RET(rRegion.GetHRGN(), wxT("invalid clipping region"));
 473      HRGN                           hRgnOld;
 474
 475      m_clipping = TRUE;
 476      ::GpiSetClipRegion( m_hPS
 477                         ,(HRGN)rRegion.GetHRGN()
 478                         ,&hRgnOld
 479                        );
 480     DO_SET_CLIPPING_BOX()
 481 } // end of wxDC::DoSetClippingRegionAsRegion
 482
 483 void wxDC::DestroyClippingRegion(void)
 484 {
 485     if (m_clipping && m_hPS)
 486     {
 487          HRGN                       hRgnOld;
 488          RECTL                      vRect;
 489
 490          // TODO: this should restore the previous clipped region
 491          //       so that OnPaint processing works correctly, and
 492          //       the update doesn't get destroyed after the first
 493          //       DestroyClippingRegion
 494          vRect.xLeft   = XLOG2DEV(0);
 495          vRect.yTop    = YLOG2DEV(32000);
 496          vRect.xRight  = XLOG2DEV(32000);
 497          vRect.yBottom = YLOG2DEV(0);
 498
 499          HRGN                       hRgn = ::GpiCreateRegion(m_hPS, 1, &vRect);
 500
 501          ::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
 502      }
 503       m_clipping = FALSE;
 504 } // end of wxDC::DestroyClippingRegion
 505
 506 // ---------------------------------------------------------------------------
 507 // query capabilities
 508 // ---------------------------------------------------------------------------
 509
 510 bool wxDC::CanDrawBitmap() const
 511 {
 512     return TRUE;
 513 }
 514
 515 bool wxDC::CanGetTextExtent() const
 516 {
 517     LONG                            lTechnology = 0L;
 518
 519     ::DevQueryCaps(GetHDC(), CAPS_TECHNOLOGY, 1L, &lTechnology);
 520     return (lTechnology == CAPS_TECH_RASTER_DISPLAY) || (lTechnology == CAPS_TECH_RASTER_PRINTER);
 521 } // end of wxDC::CanGetTextExtent
 522
 523 int wxDC::GetDepth() const
 524 {
 525     LONG                            lArray[CAPS_COLOR_BITCOUNT];
 526     int                             nBitsPerPixel;
 527
 528     if(::DevQueryCaps( GetHDC()
 529                       ,CAPS_FAMILY
 530                       ,CAPS_COLOR_BITCOUNT
 531                       ,lArray
 532                      ))
 533     {
 534         nBitsPerPixel = (int)lArray[CAPS_COLOR_BITCOUNT];
 535     }
 536     return nBitsPerPixel;
 537 } // end of wxDC::GetDepth
 538
 539 // ---------------------------------------------------------------------------
 540 // drawing
 541 // ---------------------------------------------------------------------------
 542
 543 void wxDC::Clear()
 544 {
 545     //
 546     // If this is a canvas DC then just fill with the background color
 547     // Otherwise purge the whole thing
 548     //
 549     if (m_pCanvas)
 550     {
 551         RECTL                       vRect;
 552
 553         ::GpiQueryClipBox(m_hPS, &vRect);
 554         ::WinFillRect(m_hPS, &vRect, ::GpiQueryBackColor(m_hPS));
 555     }
 556     else
 557     ::GpiErase(m_hPS);
 558 } // end of wxDC::Clear
 559
 560 bool wxDC::DoFloodFill(
 561   wxCoord                           vX
 562 , wxCoord                           vY
 563 , const wxColour&                   rCol
 564 , int                               nStyle
 565 )
 566 {
 567     POINTL                          vPtlPos;
 568     LONG                            lColor;
 569     LONG                            lOptions;
 570     LONG                            lHits;
 571     bool                            bSuccess = FALSE;
 572
 573     vPtlPos.x = vX;             // Loads x-coordinate
 574     vPtlPos.y = OS2Y(vY,0);     // Loads y-coordinate
 575     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 576     lColor = rCol.GetPixel();
 577     lOptions = FF_BOUNDARY;
 578     if(wxFLOOD_SURFACE == nStyle)
 579         lOptions = FF_SURFACE;
 580
 581     if ((lHits = ::GpiFloodFill(m_hPS, lOptions, lColor)) != GPI_ERROR)
 582         bSuccess = TRUE;
 583     return TRUE;
 584 } // end of wxDC::DoFloodFill
 585
 586 bool wxDC::DoGetPixel(
 587   wxCoord                           vX
 588 , wxCoord                           vY
 589 , wxColour*                         pCol
 590 ) const
 591 {
 592     POINTL                          vPoint;
 593     LONG                            lColor;
 594
 595     vPoint.x = vX;
 596     vPoint.y = OS2Y(vY,0);
 597     lColor = ::GpiSetPel(m_hPS, &vPoint);
 598
 599     //
 600     // Get the color of the pen
 601     //
 602     LONG                            lPencolor = 0x00ffffff;
 603
 604     if (m_pen.Ok())
 605     {
 606         lPencolor = m_pen.GetColour().GetPixel();
 607     }
 608
 609     //
 610     // return the color of the pixel
 611     //
 612     if(pCol)
 613         pCol->Set( GetRValue(lColor)
 614                   ,GetGValue(lColor)
 615                   ,GetBValue(lColor)
 616                  );
 617     return(lColor == lPencolor);
 618 } // end of wxDC::DoGetPixel
 619
 620 void wxDC::DoCrossHair(
 621   wxCoord                           vX
 622 , wxCoord                           vY
 623 )
 624 {
 625     vY = OS2Y(vY,0);
 626
 627     wxCoord                         vX1 = vX - VIEWPORT_EXTENT;
 628     wxCoord                         vY1 = vY - VIEWPORT_EXTENT;
 629     wxCoord                         vX2 = vX + VIEWPORT_EXTENT;
 630     wxCoord                         vY2 = vY + VIEWPORT_EXTENT;
 631     POINTL                          vPoint[4];
 632
 633     vPoint[0].x = vX1;
 634     vPoint[0].y = vY;
 635
 636     vPoint[1].x = vX2;
 637     vPoint[1].y = vY;
 638
 639     ::GpiMove(m_hPS, &vPoint[0]);
 640     ::GpiLine(m_hPS, &vPoint[1]);
 641
 642     vPoint[2].x = vX;
 643     vPoint[2].y = vY1;
 644
 645     vPoint[3].x = vX;
 646     vPoint[3].y = vY2;
 647
 648     ::GpiMove(m_hPS, &vPoint[2]);
 649     ::GpiLine(m_hPS, &vPoint[3]);
 650     CalcBoundingBox(vX1, vY1);
 651     CalcBoundingBox(vX2, vY2);
 652 } // end of wxDC::DoCrossHair
 653
 654 void wxDC::DoDrawLine(
 655   wxCoord                           vX1
 656 , wxCoord                           vY1
 657 , wxCoord                           vX2
 658 , wxCoord                           vY2
 659 )
 660 {
 661     POINTL                          vPoint[2];
 662
 663     vY1 = OS2Y(vY1,0);
 664     vY2 = OS2Y(vY2,0);
 665
 666     vPoint[0].x = vX1;
 667     vPoint[0].y = vY1;
 668     vPoint[1].x = vX2;
 669     vPoint[1].y = vY2;
 670     ::GpiMove(m_hPS, &vPoint[0]);
 671     ::GpiLine(m_hPS, &vPoint[1]);
 672     CalcBoundingBox(vX1, vY1);
 673     CalcBoundingBox(vX2, vY2);
 674 } // end of wxDC::DoDrawLine
 675
 676 //////////////////////////////////////////////////////////////////////////////
 677 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
 678 // and ending at (x2, y2). The current pen is used for the outline and the
 679 // current brush for filling the shape. The arc is drawn in an anticlockwise
 680 // direction from the start point to the end point.
 681 //////////////////////////////////////////////////////////////////////////////
 682 void wxDC::DoDrawArc(
 683   wxCoord                           vX1
 684 , wxCoord                           vY1
 685 , wxCoord                           vX2
 686 , wxCoord                           vY2
 687 , wxCoord                           vXc
 688 , wxCoord                           vYc
 689 )
 690 {
 691      POINTL                         vPtlPos;
 692      POINTL                         vPtlArc[2]; // Structure for current position
 693      int                            nDx;
 694      int                            nDy;
 695      double                         dRadius;
 696      double                         dAngl1;
 697      double                         dAngl2;
 698      double                         dAnglmid;
 699      wxCoord                        vXm;
 700      wxCoord                        vYm;
 701      ARCPARAMS                      vArcp; // Structure for arc parameters
 702
 703     if((vX1 == vXc && vY1 == vXc) || (vX2 == vXc && vY2 == vXc))
 704         return; // Draw point ??
 705     dRadius = 0.5 * ( hypot( (double)(vY1 - vYc)
 706                             ,(double)(vX1 - vXc)
 707                            ) +
 708                       hypot( (double)(vY2 - vYc)
 709                             ,(double)(vX2 - vXc)
 710                            )
 711                      );
 712
 713     dAngl1 = atan2( (double)(vY1 - vYc)
 714                    ,(double)(vX1 - vXc)
 715                   );
 716     dAngl2 = atan2( (double)(vY2 - vYc)
 717                    ,(double)(vX2 - vXc)
 718                   );
 719     if(dAngl2 < dAngl1)
 720         dAngl2 += M_PI * 2;
 721
 722     //
 723     // GpiPointArc can't draw full arc
 724     //
 725      if(dAngl2 == dAngl1 || (vX1 == vX2 && vY1 == vY2) )
 726      {
 727         //
 728         // Medium point
 729         //
 730         dAnglmid = (dAngl1 + dAngl2)/2. + M_PI;
 731         vXm      = vXc + dRadius * cos(dAnglmid);
 732         vYm      = vYc + dRadius * sin(dAnglmid);
 733         DoDrawArc( vX1, vY1
 734                   ,vXm, vYm
 735                   ,vXc, vYc
 736                  );
 737         DoDrawArc( vXm, vYm
 738                   ,vX2, vY2
 739                   ,vXc, vYc
 740                  );
 741         return;
 742     }
 743
 744     //
 745     // Medium point
 746     //
 747     dAnglmid = (dAngl1 + dAngl2)/2.;
 748     vXm      = vXc + dRadius * cos(dAnglmid);
 749     vYm      = vYc + dRadius * sin(dAnglmid);
 750
 751     //
 752     // Ellipse main axis (r,q), (p,s) with center at (0,0) */
 753     //
 754     vArcp.lR = 0;
 755     vArcp.lQ = 1;
 756     vArcp.lP = 1;
 757     vArcp.lS = 0;
 758     ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
 759
 760     vPtlPos.x = vX1; // Loads x-coordinate
 761     vPtlPos.y = vY1; // Loads y-coordinate
 762     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
 763     vPtlArc[0].x = vXm;
 764     vPtlArc[0].y = vYm;
 765     vPtlArc[1].x = vX2;
 766     vPtlArc[1].y = vY2;
 767     ::GpiPointArc(m_hPS, vPtlArc); // Draws the arc
 768     CalcBoundingBox( (vXc - dRadius)
 769                     ,(vYc - dRadius)
 770                    );
 771     CalcBoundingBox( (vXc + dRadius)
 772                     ,(vYc + dRadius)
 773                    );
 774 } // end of wxDC::DoDrawArc
 775
 776 void wxDC::DoDrawCheckMark(
 777   wxCoord                           vX1
 778 , wxCoord                           vY1
 779 , wxCoord                           vWidth
 780 , wxCoord                           vHeight
 781 )
 782 {
 783     POINTL                          vPoint[2];
 784
 785     vY1 = OS2Y(vY1,vHeight);
 786
 787     vPoint[0].x = vX1;
 788     vPoint[0].y = vY1;
 789     vPoint[1].x = vX1 + vWidth;
 790     vPoint[1].y = vY1 + vHeight;
 791
 792     ::GpiMove(m_hPS, &vPoint[0]);
 793     ::GpiBox( m_hPS       // handle to a presentation space
 794              ,DRO_OUTLINE // draw the box outline ? or ?
 795              ,&vPoint[1]  // address of the corner
 796              ,0L          // horizontal corner radius
 797              ,0L          // vertical corner radius
 798             );
 799     if(vWidth > 4 && vHeight > 4)
 800     {
 801         int                         nTmp;
 802
 803         vPoint[0].x += 2; vPoint[0].y += 2;
 804         vPoint[1].x -= 2; vPoint[1].y -= 2;
 805         ::GpiMove(m_hPS, &vPoint[0]);
 806         ::GpiLine(m_hPS, &vPoint[1]);
 807         nTmp = vPoint[0].x;
 808         vPoint[0].x = vPoint[1].x;
 809         vPoint[1].x = nTmp;
 810         ::GpiMove(m_hPS, &vPoint[0]);
 811         ::GpiLine(m_hPS, &vPoint[1]);
 812     }
 813     CalcBoundingBox( vX1
 814                     ,vY1
 815                    );
 816
 817     wxCoord                         vX2 = vX1 + vWidth;
 818     wxCoord                         vY2 = vY1 + vHeight;
 819
 820     CalcBoundingBox( vX2
 821                     ,vY2
 822                    );
 823 } // end of wxDC::DoDrawCheckMark
 824
 825 void wxDC::DoDrawPoint(
 826   wxCoord                           vX
 827 , wxCoord                           vY
 828 )
 829 {
 830     POINTL                          vPoint;
 831     COLORREF                        vColor = 0x00ffffff;
 832
 833     if (m_pen.Ok())
 834     {
 835         vColor = m_pen.GetColour().GetPixel();
 836     }
 837     ::GpiSetColor(m_hPS, vColor);
 838     vPoint.x = vX;
 839     vPoint.y = OS2Y(vY,0);
 840     ::GpiSetPel(m_hPS, &vPoint);
 841     CalcBoundingBox( vX
 842                     ,vY
 843                    );
 844 } // end of wxDC::DoDrawPoint
 845
 846 void wxDC::DoDrawPolygon(
 847   int                               n
 848 , wxPoint                           vPoints[]
 849 , wxCoord                           vXoffset
 850 , wxCoord                           vYoffset
 851 , int                               nFillStyle
 852 )
 853 {
 854     ULONG                           ulCount = 1;    // Number of polygons.
 855     POLYGON                         vPlgn;          // polygon.
 856     ULONG                           flOptions = 0L; // Drawing options.
 857
 858 //////////////////////////////////////////////////////////////////////////////
 859 // This contains fields of option bits... to draw boundary lines as well as
 860 // the area interior.
 861 //
 862 // Drawing boundary lines:
 863 //   POLYGON_NOBOUNDARY              Does not draw boundary lines.
 864 //   POLYGON_BOUNDARY                Draws boundary lines (the default).
 865 //
 866 // Construction of the area interior:
 867 //   POLYGON_ALTERNATE               Constructs interior in alternate mode
 868 //                                   (the default).
 869 //   POLYGON_WINDING                 Constructs interior in winding mode.
 870 //////////////////////////////////////////////////////////////////////////////
 871
 872     ULONG                           flModel = 0L; // Drawing model.
 873
 874 //////////////////////////////////////////////////////////////////////////////
 875 // Drawing model.
 876 //   POLYGON_INCL  Fill is inclusive of bottom right (the default).
 877 //   POLYGON_EXCL  Fill is exclusive of bottom right.
 878 //       This is provided to aid migration from other graphics models.
 879 //////////////////////////////////////////////////////////////////////////////
 880
 881     LONG                            lHits = 0L; // Correlation/error indicator.
 882     POINTL                          vPoint;
 883     int                             i;
 884     int                             nIsTRANSPARENT = 0;
 885     LONG                            lBorderColor = 0L;
 886     LONG                            lColor = 0L;
 887
 888     lBorderColor = m_pen.GetColour().GetPixel();
 889     lColor       = m_brush.GetColour().GetPixel();
 890     if(m_brush.GetStyle() == wxTRANSPARENT)
 891         nIsTRANSPARENT = 1;
 892
 893     vPlgn.ulPoints = n;
 894     vPlgn.aPointl = (POINTL*) calloc( n + 1
 895                                      ,sizeof(POINTL)
 896                                     ); // well, new will call malloc
 897
 898     for(i = 0; i < n; i++)
 899     {
 900         vPlgn.aPointl[i].x = vPoints[i].x;         // +xoffset;
 901         vPlgn.aPointl[i].y = OS2Y(vPoints[i].y,0); // +yoffset;
 902     }
 903     flModel = POLYGON_BOUNDARY;
 904     if(nFillStyle == wxWINDING_RULE)
 905         flModel |= POLYGON_WINDING;
 906     else
 907         flModel |= POLYGON_ALTERNATE;
 908
 909     vPoint.x = vXoffset;
 910     vPoint.y = OS2Y(vYoffset,0);
 911
 912     ::GpiSetColor(m_hPS, lBorderColor);
 913     ::GpiMove(m_hPS, &vPoint);
 914     lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
 915     free(vPlgn.aPointl);
 916 } // end of wxDC::DoDrawPolygon
 917
 918 void wxDC::DoDrawLines(
 919   int                               n
 920 , wxPoint                           vPoints[]
 921 , wxCoord                           vXoffset
 922 , wxCoord                           vYoffset
 923 )
 924 {
 925     POINTL                          vPoint;
 926
 927     if (vXoffset != 0L || vXoffset != 0L)
 928     {
 929         int                             i;
 930
 931         vPoint.x = vPoints[0].x + vXoffset;
 932         vPoint.y = OS2Y(vPoints[0].y + vYoffset,0);
 933         ::GpiMove(m_hPS, &vPoint);
 934
 935         LONG                            lBorderColor = m_pen.GetColour().GetPixel();
 936
 937         ::GpiSetColor(m_hPS, lBorderColor);
 938         for(i = 1; i < n; i++)
 939         {
 940             vPoint.x = vPoints[i].x + vXoffset;
 941             vPoint.y = OS2Y(vPoints[i].y + vYoffset,0);
 942             ::GpiLine(m_hPS, &vPoint);
 943         }
 944     }
 945     else
 946     {
 947         int                         i;
 948
 949         CalcBoundingBox( vPoints[i].x
 950                         ,vPoints[i].y
 951                        );
 952         vPoint.x = vPoints[0].x;
 953         vPoint.y = OS2Y(vPoints[0].y,0);
 954         ::GpiMove(m_hPS, &vPoint);
 955
 956         for (i = 0; i < n; i++)
 957         {
 958             CalcBoundingBox( vPoints[i].x
 959                             ,vPoints[i].y
 960                            );
 961             vPoint.x = vPoints[i].x;
 962             vPoint.y = OS2Y(vPoints[i].y,0);
 963             ::GpiLine(m_hPS, &vPoint);
 964         }
 965     }
 966 } // end of wxDC::DoDrawLines
 967
 968 void wxDC::DoDrawRectangle(
 969   wxCoord                           vX
 970 , wxCoord                           vY
 971 , wxCoord                           vWidth
 972 , wxCoord                           vHeight
 973 )
 974 {
 975     POINTL                          vPoint[2];
 976     LONG                            lControl;
 977     LONG                            lColor;
 978     LONG                            lBorderColor;
 979     int                             nIsTRANSPARENT = 0;
 980
 981     //
 982     // Might be a memory DC with no Paint rect
 983     //
 984     if (!(m_vRclPaint.yTop == 0 &&
 985           m_vRclPaint.yBottom == 0 &&
 986           m_vRclPaint.xRight == 0 &&
 987           m_vRclPaint.xLeft == 0))
 988         vY = OS2Y(vY,vHeight);
 989
 990     wxCoord                         vX2 = vX + vWidth;
 991     wxCoord                         vY2 = vY + vHeight;
 992
 993     vPoint[0].x = vX;
 994     vPoint[0].y = vY;
 995     vPoint[1].x = vX + vWidth - 1;
 996     vPoint[1].y = vY + vHeight - 1;
 997     ::GpiMove(m_hPS, &vPoint[0]);
 998     lColor       = m_brush.GetColour().GetPixel();
 999     lBorderColor = m_pen.GetColour().GetPixel();
1000     if (m_brush.GetStyle() == wxTRANSPARENT)
1001         nIsTRANSPARENT = 1;
1002     if(lColor == lBorderColor || nIsTRANSPARENT)
1003     {
1004         lControl = DRO_OUTLINEFILL; //DRO_FILL;
1005         if(m_brush.GetStyle() == wxTRANSPARENT)
1006             lControl = DRO_OUTLINE;
1007
1008         ::GpiSetColor(m_hPS, lColor);
1009         ::GpiBox( m_hPS       // handle to a presentation space
1010                  ,lControl   // draw the box outline ? or ?
1011                  ,&vPoint[1]  // address of the corner
1012                  ,0L          // horizontal corner radius
1013                  ,0L          // vertical corner radius
1014                 );
1015     }
1016     else
1017     {
1018         lControl = DRO_OUTLINE;
1019         ::GpiSetColor( m_hPS
1020                       ,lBorderColor
1021                      );
1022         ::GpiBox( m_hPS
1023                  ,lControl
1024                  ,&vPoint[1]
1025                  ,0L
1026                  ,0L
1027                 );
1028         lControl = DRO_FILL;
1029         ::GpiSetColor( m_hPS
1030                       ,lColor
1031                      );
1032         vPoint[0].x = vX + 1;
1033         vPoint[0].y = vY + 1;
1034         vPoint[1].x = vX + vWidth - 2;
1035         vPoint[1].y = vY + vHeight - 2;
1036         ::GpiMove(m_hPS, &vPoint[0]);
1037         ::GpiBox( m_hPS
1038                  ,lControl
1039                  ,&vPoint[1]
1040                  ,0L
1041                  ,0L
1042                 );
1043     }
1044     CalcBoundingBox(vX, vY);
1045     CalcBoundingBox(vX2, vY2);
1046 } // end of wxDC::DoDrawRectangle
1047
1048 void wxDC::DoDrawRoundedRectangle(
1049   wxCoord                           vX
1050 , wxCoord                           vY
1051 , wxCoord                           vWidth
1052 , wxCoord                           vHeight
1053 , double                            dRadius
1054 )
1055 {
1056     POINTL                          vPoint[2];
1057     LONG                            lControl;
1058
1059     vY = OS2Y(vY,vHeight);
1060
1061     wxCoord                         vX2 = (vX + vWidth);
1062     wxCoord                         vY2 = (vY + vHeight);
1063
1064     vPoint[0].x = vX;
1065     vPoint[0].y = YLOG2DEV(vY) - vHeight;
1066     vPoint[1].x = vX + vWidth;
1067     vPoint[1].y = vY;
1068     ::GpiMove(m_hPS, &vPoint[0]);
1069
1070     lControl = DRO_OUTLINEFILL; //DRO_FILL;
1071     if (m_brush.GetStyle() == wxTRANSPARENT)
1072         lControl = DRO_OUTLINE;
1073     ::GpiBox( m_hPS         // handle to a presentation space
1074              ,DRO_OUTLINE   // draw the box outline ? or ?
1075              ,&vPoint[1]    // address of the corner
1076              ,(LONG)dRadius // horizontal corner radius
1077              ,(LONG)dRadius // vertical corner radius
1078             );
1079     CalcBoundingBox(vX, vY);
1080     CalcBoundingBox(vX2, vY2);
1081 } // end of wxDC::DoDrawRoundedRectangle
1082
1083 // Draw Ellipse within box (x,y) - (x+width, y+height)
1084 void wxDC::DoDrawEllipse(
1085   wxCoord                           vX
1086 , wxCoord                           vY
1087 , wxCoord                           vWidth
1088 , wxCoord                           vHeight
1089 )
1090 {
1091     POINTL                          vPtlPos; // Structure for current position
1092     FIXED                           vFxMult; // Multiplier for ellipse
1093     ARCPARAMS                       vArcp;   // Structure for arc parameters
1094
1095     vY = OS2Y(vY,vHeight);
1096
1097     vArcp.lR = 0;
1098     vArcp.lQ = vHeight/2;
1099     vArcp.lP = vWidth/2;
1100     vArcp.lS = 0;
1101     ::GpiSetArcParams( m_hPS
1102                       ,&vArcp
1103                      ); // Sets parameters to default
1104     vPtlPos.x = vX + vWidth/2;  // Loads x-coordinate
1105     vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
1106     ::GpiMove( m_hPS
1107               ,&vPtlPos
1108              ); // Sets current position
1109     vFxMult = MAKEFIXED(1, 0);             /* Sets multiplier            */
1110
1111     //
1112     // DRO_FILL, DRO_OTLINEFILL - where to get
1113     //
1114     ::GpiFullArc( m_hPS
1115                  ,DRO_OUTLINE
1116                  ,vFxMult
1117                 ); // Draws full arc with center at current position
1118
1119     wxCoord                         vX2 = (vX + vWidth);
1120     wxCoord                         vY2 = (vY + vHeight);
1121
1122     CalcBoundingBox(vX, vY);
1123     CalcBoundingBox(vX2, vY2);
1124 } // end of wxDC::DoDrawEllipse
1125
1126 void wxDC::DoDrawEllipticArc(
1127   wxCoord                           vX
1128 , wxCoord                           vY
1129 , wxCoord                           vWidth
1130 , wxCoord                           vHeight
1131 , double                            dSa
1132 , double                            dEa
1133 )
1134 {
1135     POINTL                          vPtlPos; // Structure for current position
1136     FIXED                           vFxMult; // Multiplier for ellipse
1137     ARCPARAMS                       vArcp;   // Structure for arc parameters
1138     FIXED                           vFSa;
1139     FIXED                           vFSweepa; // Start angle, sweep angle
1140     double                          dIntPart;
1141     double                          dFractPart;
1142     double                          dRadius;
1143
1144     vY = OS2Y(vY,vHeight);
1145
1146     dFractPart = modf(dSa,&dIntPart);
1147     vFSa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
1148     dFractPart = modf(dEa - dSa, &dIntPart);
1149     vFSweepa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
1150
1151     //
1152     // Ellipse main axis (r,q), (p,s) with center at (0,0)
1153     //
1154     vArcp.lR = 0;
1155     vArcp.lQ = vHeight/2;
1156     vArcp.lP = vWidth/2;
1157     vArcp.lS = 0;
1158     ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
1159     vPtlPos.x = vX + vWidth/2  * (1. + cos(DegToRad(dSa))); // Loads x-coordinate
1160     vPtlPos.y = vY + vHeight/2 * (1. + sin(DegToRad(dSa))); // Loads y-coordinate
1161     ::GpiMove(m_hPS, &vPtlPos); // Sets current position
1162
1163     //
1164     // May be not to the center ?
1165     //
1166     vPtlPos.x = vX + vWidth/2 ; // Loads x-coordinate
1167     vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
1168     vFxMult = MAKEFIXED(1, 0);  // Sets multiplier
1169
1170     //
1171     // DRO_FILL, DRO_OTLINEFILL - where to get
1172     //
1173     ::GpiPartialArc( m_hPS
1174                     ,&vPtlPos
1175                     ,vFxMult
1176                     ,vFSa
1177                     ,vFSweepa
1178                    );
1179     wxCoord                         vX2 = (vX + vWidth);
1180     wxCoord                         vY2 = (vY + vHeight);
1181
1182     CalcBoundingBox(vX, vY);
1183     CalcBoundingBox(vX2, vY2);
1184 } // end of wxDC::DoDrawEllipticArc
1185
1186 void wxDC::DoDrawIcon(
1187   const wxIcon&                     rIcon
1188 , wxCoord                           vX
1189 , wxCoord                           vY
1190 )
1191 {
1192     vY = OS2Y(vY,rIcon.GetHeight());
1193     wxCHECK_RET( rIcon.Ok(), wxT("invalid icon in DrawIcon") );
1194
1195     ::WinDrawPointer( GetHPS()
1196                      ,vX
1197                      ,vY
1198                      ,(HPOINTER)GetHiconOf(rIcon)
1199                      ,DP_NORMAL
1200                     );
1201     CalcBoundingBox(vX, vY);
1202     CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
1203 } // end of wxDC::DoDrawIcon
1204
1205 void wxDC::DoDrawBitmap(
1206   const wxBitmap&                   rBmp
1207 , wxCoord                           vX
1208 , wxCoord                           vY
1209 , bool                              bUseMask
1210 )
1211 {
1212     if (!IsKindOf(CLASSINFO(wxPrinterDC)))
1213     {
1214         HBITMAP                         hBitmap =  (HBITMAP)rBmp.GetHBITMAP();
1215         wxBitmap                        vNewBitmap( rBmp.GetWidth()
1216                                                    ,rBmp.GetHeight()
1217                                                    ,rBmp.GetDepth()
1218                                                   );
1219         HBITMAP                         hBitmapOld = ::GpiSetBitmap((HPS)GetHPS(), vNewBitmap.GetHBITMAP());
1220         LONG                            lOldTextground = ::GpiQueryColor((HPS)GetHPS());
1221         LONG                            lOldBackground = ::GpiQueryBackColor((HPS)GetHPS());
1222
1223         vY = OS2Y(vY,rBmp.GetHeight());
1224
1225         //
1226         // Flip the picture as OS/2 is upside-down
1227         //
1228         POINTL                      vPoint[4] = { vX, vY + rBmp.GetHeight()
1229                                                  ,vX + rBmp.GetWidth(), vY
1230                                                  ,0, 0
1231                                                  ,rBmp.GetWidth(), rBmp.GetHeight()
1232                                                 };
1233
1234         if (m_textForegroundColour.Ok())
1235         {
1236             ::GpiSetColor( (HPS)GetHPS()
1237                            ,m_textForegroundColour.GetPixel()
1238                           );
1239         }
1240         if (m_textBackgroundColour.Ok())
1241         {
1242             ::GpiSetBackColor( (HPS)GetHPS()
1243                               ,m_textBackgroundColour.GetPixel()
1244                              );
1245         }
1246         if (bUseMask)
1247         {
1248             wxMask*                     pMask = rBmp.GetMask();
1249             HPS                         hPS;
1250             HDC                         hDC;
1251
1252             if (!IsKindOf(CLASSINFO(wxMemoryDC)))
1253             {
1254                 DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1255                 SIZEL                           vSize = {0, 0};
1256
1257                 hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1258                 hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
1259             }
1260             else
1261                 hPS = m_hPS;
1262
1263             if (pMask)
1264             {
1265                 BITMAPINFOHEADER2           vHeader;
1266                 BITMAPINFO2                 vInfo;
1267                 int                         nBytesPerLine = rBmp.GetWidth() * 3;
1268                 unsigned char*              pucData;
1269                 LONG                        lScans = 0L;
1270                 LONG                        alFormats[24]; // Max formats OS/2 PM supports
1271                 ULONG                       ulBitcount;
1272                 HBITMAP                     hMask = (HBITMAP)pMask->GetMaskBitmap();
1273                 POINTL                      vPointMask[4] = { 0, 0, rBmp.GetWidth(), rBmp.GetHeight()
1274                                                              ,0, 0, rBmp.GetWidth(), rBmp.GetHeight()
1275                                                             };
1276
1277                 ::GpiSetBitmap(hPS, hMask);
1278
1279                 ::GpiQueryDeviceBitmapFormats(hPS, 24, alFormats);
1280                 ulBitcount = alFormats[1]; // the best one
1281                 if (ulBitcount > 24) // PM supports a max of 24
1282                     ulBitcount = 24;
1283
1284                 vInfo.cbFix     = 16;
1285                 vInfo.cx        = rBmp.GetWidth();
1286                 vInfo.cy        = rBmp.GetHeight();
1287                 vInfo.cPlanes   = 1;
1288                 vInfo.cBitCount = ulBitcount;
1289                 pucData = (unsigned char*)malloc(nBytesPerLine * rBmp.GetHeight());
1290                 if ((lScans = ::GpiQueryBitmapBits( hPS
1291                                                    ,0L
1292                                                    ,(LONG)rBmp.GetHeight()
1293                                                    ,(PBYTE)pucData
1294                                                    ,&vInfo
1295                                                   )) == GPI_ALTERROR)
1296                 {
1297                     ERRORID                     vError;
1298                     wxString                    sError;
1299
1300                     vError = ::WinGetLastError(vHabmain);
1301                     sError = wxPMErrorToStr(vError);
1302                 }
1303                 if ((hBitmapOld = ::GpiSetBitmap(hPS, (HBITMAP)vNewBitmap.GetHBITMAP())) == HBM_ERROR)
1304                 {
1305                     ERRORID                     vError;
1306                     wxString                    sError;
1307
1308                     vError = ::WinGetLastError(vHabmain);
1309                     sError = wxPMErrorToStr(vError);
1310                 }
1311                 if ((lScans = ::GpiSetBitmapBits( hPS
1312                                                  ,0
1313                                                  ,(LONG)rBmp.GetHeight()
1314                                                  ,(PBYTE)pucData
1315                                                  ,&vInfo
1316                                                 )) == GPI_ALTERROR)
1317                 {
1318                     ERRORID                 vError;
1319                     wxString                sError;
1320
1321                     vError = ::WinGetLastError(vHabmain);
1322                     sError = wxPMErrorToStr(vError);
1323                 }
1324                 if ((hBitmapOld = ::GpiSetBitmap(hPS, NULLHANDLE)) == HBM_ERROR)
1325                 {
1326                     ERRORID                     vError;
1327                     wxString                    sError;
1328
1329                     vError = ::WinGetLastError(vHabmain);
1330                     sError = wxPMErrorToStr(vError);
1331                 }
1332                 if ((hBitmapOld = ::GpiSetBitmap((HPS)GetHPS(), vNewBitmap.GetHBITMAP())) == HBM_ERROR)
1333                 {
1334                     ERRORID                     vError;
1335                     wxString                    sError;
1336
1337                     vError = ::WinGetLastError(vHabmain);
1338                     sError = wxPMErrorToStr(vError);
1339                 }
1340                 ::GpiWCBitBlt( (HPS)GetHPS()
1341                               ,hBitmap
1342                               ,4
1343                               ,vPoint
1344                               ,ROP_SRCAND
1345                               ,BBO_IGNORE
1346                              );
1347             }
1348         }
1349         else
1350         {
1351             ::GpiWCBitBlt( (HPS)GetHPS()
1352                           ,hBitmap
1353                           ,4
1354                           ,vPoint
1355                           ,ROP_SRCCOPY
1356                           ,BBO_IGNORE
1357                          );
1358         }
1359         ::GpiSetBitmap((HPS)GetHPS(), hBitmapOld);
1360         ::GpiSetColor((HPS)GetHPS(), lOldTextground);
1361         ::GpiSetBackColor((HPS)GetHPS(), lOldBackground);
1362     }
1363 } // end of wxDC::DoDrawBitmap
1364
1365 void wxDC::DoDrawText(
1366   const wxString&                   rsText
1367 , wxCoord                           vX
1368 , wxCoord                           vY
1369 )
1370 {
1371     wxCoord                         vWidth;
1372     wxCoord                         vHeight;
1373
1374     DrawAnyText( rsText
1375                 ,vX
1376                 ,vY
1377                );
1378
1379     CalcBoundingBox(vX, vY);
1380     GetTextExtent(rsText, &vWidth, &vHeight);
1381     CalcBoundingBox((vX + vWidth), (vY + vHeight));
1382 } // end of wxDC::DoDrawText
1383
1384 void wxDC::DrawAnyText(
1385   const wxString&                   rsText
1386 , wxCoord                           vX
1387 , wxCoord                           vY
1388 )
1389 {
1390     int                             nOldBackground = 0;
1391     POINTL                          vPtlStart;
1392     LONG                            lHits;
1393     wxCoord                         vTextX = 0;
1394     wxCoord                         vTextY = 0;
1395
1396     //
1397     // prepare for drawing the text
1398     //
1399
1400     //
1401     // Set text color attributes
1402     //
1403     if (m_textForegroundColour.Ok())
1404     {
1405         SetTextColor( m_hPS
1406                      ,(int)m_textForegroundColour.GetPixel()
1407                     );
1408     }
1409
1410     if (m_textBackgroundColour.Ok())
1411     {
1412         nOldBackground = SetTextBkColor( m_hPS
1413                                         ,(int)m_textBackgroundColour.GetPixel()
1414                                        );
1415     }
1416     SetBkMode( m_hPS
1417               ,m_backgroundMode
1418              );
1419     GetTextExtent( rsText
1420                   ,&vTextX
1421                   ,&vTextY
1422                  );
1423     vPtlStart.x = vX;
1424     vPtlStart.y = OS2Y(vY,vTextY);
1425
1426     lHits = ::GpiCharStringAt( m_hPS
1427                               ,&vPtlStart
1428                               ,rsText.length()
1429                               ,(PCH)rsText.c_str()
1430                              );
1431     if (lHits != GPI_OK)
1432     {
1433         wxLogLastError(wxT("TextOut"));
1434     }
1435
1436     //
1437     // Restore the old parameters (text foreground colour may be left because
1438     // it never is set to anything else, but background should remain
1439     // transparent even if we just drew an opaque string)
1440     //
1441     if (m_textBackgroundColour.Ok())
1442             SetTextBkColor( m_hPS
1443                            ,nOldBackground
1444                           );
1445     SetBkMode( m_hPS
1446               ,wxTRANSPARENT
1447              );
1448 }
1449
1450 void wxDC::DoDrawRotatedText(
1451   const wxString&                   rsText
1452 , wxCoord                           vX
1453 , wxCoord                           vY
1454 , double                            dAngle
1455 )
1456 {
1457     if (dAngle == 0.0)
1458     {
1459         DoDrawText( rsText
1460                    ,vX
1461                    ,vY
1462                   );
1463     }
1464
1465    // TODO:
1466    /*
1467     if ( angle == 0.0 )
1468     {
1469         DoDrawText(text, x, y);
1470     }
1471     else
1472     {
1473         LOGFONT lf;
1474         wxFillLogFont(&lf, &m_font);
1475
1476         // GDI wants the angle in tenth of degree
1477         long angle10 = (long)(angle * 10);
1478         lf.lfEscapement = angle10;
1479         lf. lfOrientation = angle10;
1480
1481         HFONT hfont = ::CreateFontIndirect(&lf);
1482         if ( !hfont )
1483         {
1484             wxLogLastError("CreateFont");
1485         }
1486         else
1487         {
1488             HFONT hfontOld = ::SelectObject(GetHdc(), hfont);
1489
1490             DrawAnyText(text, x, y);
1491
1492             (void)::SelectObject(GetHdc(), hfontOld);
1493         }
1494
1495         // call the bounding box by adding all four vertices of the rectangle
1496         // containing the text to it (simpler and probably not slower than
1497         // determining which of them is really topmost/leftmost/...)
1498         wxCoord w, h;
1499         GetTextExtent(text, &w, &h);
1500
1501         double rad = DegToRad(angle);
1502
1503         // "upper left" and "upper right"
1504         CalcBoundingBox(x, y);
1505         CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
1506         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
1507
1508         // "bottom left" and "bottom right"
1509         x += (wxCoord)(h*sin(rad));
1510         y += (wxCoord)(h*cos(rad));
1511         CalcBoundingBox(x, y);
1512         CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
1513     }
1514 */
1515 }
1516
1517 // ---------------------------------------------------------------------------
1518 // set GDI objects
1519 // ---------------------------------------------------------------------------
1520
1521 void wxDC::DoSelectPalette(
1522   bool                              bRealize
1523 )
1524 {
1525     //
1526     // Set the old object temporarily, in case the assignment deletes an object
1527     // that's not yet selected out.
1528     //
1529     if (m_hOldPalette)
1530     {
1531         m_hOldPalette = 0;
1532     }
1533
1534     if (m_palette.Ok())
1535     {
1536         HPALETTE                    hOldPal;
1537
1538         hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
1539         if (!m_hOldPalette)
1540             m_hOldPalette = (WXHPALETTE)hOldPal;
1541     }
1542 } // end of wxDC::DoSelectPalette
1543
1544 void wxDC::InitializePalette()
1545 {
1546     if (wxDisplayDepth() <= 8 )
1547     {
1548         //
1549         // Look for any window or parent that has a custom palette. If any has
1550         // one then we need to use it in drawing operations
1551         //
1552         wxWindow*                   pWin = m_pCanvas->GetAncestorWithCustomPalette();
1553
1554         m_hasCustomPalette = pWin && pWin->HasCustomPalette();
1555         if (m_hasCustomPalette)
1556         {
1557             m_palette = pWin->GetPalette();
1558
1559             //
1560             // turn on PM translation for this palette
1561             //
1562             DoSelectPalette();
1563         }
1564     }
1565 } // end of wxDC::InitializePalette
1566
1567 void wxDC::SetPalette(
1568   const wxPalette&                  rPalette
1569 )
1570 {
1571     if (m_hOldFont)
1572     {
1573         m_hOldFont = 0;
1574     }
1575     m_palette = rPalette;
1576     if (!rPalette.Ok())
1577     {
1578         if (m_hOldFont)
1579         {
1580             m_hOldFont = 0;
1581         }
1582     }
1583     HPALETTE                    hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
1584     if (!m_hOldPalette)
1585         m_hOldPalette = (WXHPALETTE)hOldPal;
1586 } // end of wxDC::SetPalette
1587
1588 void wxDC::SetFont(
1589   const wxFont&                     rFont
1590 )
1591 {
1592     //
1593     // Set the old object temporarily, in case the assignment deletes an object
1594     // that's not yet selected out.
1595     //
1596     if (m_hOldFont)
1597     {
1598         m_hOldFont = 0;
1599     }
1600     m_font = rFont;
1601     if (!rFont.Ok())
1602     {
1603         m_hOldFont = 0;
1604     }
1605
1606     m_font.SetPS(m_hPS); // this will realize the font
1607
1608     if (m_font.Ok())
1609     {
1610         HFONT                       hFont = m_font.GetResourceHandle();
1611         if (hFont == (HFONT) NULL)
1612         {
1613             wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
1614         }
1615         if (!m_hOldFont)
1616             m_hOldFont = (WXHFONT) hFont;
1617     }
1618 } // end of wxDC::SetFont
1619
1620 void wxDC::SetPen(
1621   const wxPen&                      rPen
1622 )
1623 {
1624     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1625
1626     if (m_pen == rPen)
1627         return;
1628     m_pen = rPen;
1629     if (!m_pen.Ok())
1630         return;
1631
1632     if (m_hOldPen)
1633         m_hOldPen = 0L;
1634     m_pen = rPen;
1635
1636     if (!m_pen.Ok())
1637     {
1638         if (m_hOldPen)
1639         {
1640             m_pen.SetPS((HPS)m_hOldPen);
1641         }
1642         m_hOldPen = 0L;
1643     }
1644
1645     if (m_pen.Ok())
1646     {
1647         if (m_pen.GetResourceHandle())
1648         {
1649             m_pen.SetPS(m_hPS);
1650             if (!m_hOldPen)
1651                 m_hOldPen = m_pen.GetPS();
1652         }
1653     }
1654 }
1655
1656 void wxDC::SetBrush(
1657   const wxBrush&                    rBrush
1658 )
1659 {
1660     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1661
1662     if (m_hOldBrush)
1663         m_hOldBrush = 0L;
1664     m_brush = rBrush;
1665     if (!m_brush.Ok())
1666     if (m_brush == rBrush)
1667         return;
1668     if (!m_brush.Ok())
1669         if (m_hOldBrush)
1670             m_hOldBrush = 0L;
1671
1672     if (!m_brush.Ok())
1673     {
1674         if (m_hOldBrush)
1675         {
1676             m_brush.SetPS((HPS)m_hOldBrush);
1677         }
1678         m_hOldBrush = 0L;
1679     }
1680
1681     if (m_brush.Ok())
1682     {
1683         if (m_brush.GetResourceHandle())
1684         {
1685             m_brush.SetPS(m_hPS);
1686             if (!m_hOldBrush)
1687                 m_hOldBrush = (WXHWND)m_brush.GetPS();
1688         }
1689     }
1690 } // end of wxDC::SetBrush
1691
1692 void wxDC::SetBackground(
1693   const wxBrush&                    rBrush
1694 )
1695 {
1696     m_backgroundBrush = rBrush;
1697     if (!m_backgroundBrush.Ok())
1698         return;
1699     if (m_pCanvas)
1700     {
1701         bool                        bCustomColours = TRUE;
1702
1703         //
1704         // If we haven't specified wxUSER_COLOURS, don't allow the panel/dialog box to
1705         // change background colours from the control-panel specified colours.
1706         //
1707         if (m_pCanvas->IsKindOf(CLASSINFO(wxWindow)) &&
1708             ((m_pCanvas->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
1709             bCustomColours = FALSE;
1710         if (bCustomColours)
1711         {
1712             if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
1713             {
1714                 m_pCanvas->SetTransparent(TRUE);
1715             }
1716             else
1717             {
1718                 //
1719                 // Setting the background brush of a DC
1720                 // doesn't affect the window background colour. However,
1721                 // I'm leaving in the transparency setting because it's needed by
1722                 // various controls (e.g. wxStaticText) to determine whether to draw
1723                 // transparently or not. TODO: maybe this should be a new function
1724                 // wxWindow::SetTransparency(). Should that apply to the child itself, or the
1725                 // parent?
1726                 // m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
1727                 //
1728                 m_pCanvas->SetTransparent(FALSE);
1729             }
1730         }
1731     }
1732     COLORREF                        vNewColor = m_backgroundBrush.GetColour().GetPixel();
1733     (void)::GpiSetBackColor((HPS)m_hPS, (LONG)vNewColor);
1734 } // end of wxDC::SetBackground
1735
1736 void wxDC::SetBackgroundMode(
1737   int                               nMode
1738 )
1739 {
1740     m_backgroundMode = nMode;
1741 } // end of wxDC::SetBackgroundMode
1742
1743 void wxDC::SetLogicalFunction(
1744   int                               nFunction
1745 )
1746 {
1747     m_logicalFunction = nFunction;
1748     SetRop((WXHDC)m_hDC);
1749 } // wxDC::SetLogicalFunction
1750
1751 void wxDC::SetRop(
1752   WXHDC                             hDC
1753 )
1754 {
1755     if (!hDC || m_logicalFunction < 0)
1756         return;
1757
1758     LONG                            lCRop;
1759     switch (m_logicalFunction)
1760     {
1761         case wxXOR:
1762             lCRop = FM_XOR;
1763             break;
1764
1765         case wxINVERT:
1766             lCRop = FM_INVERT;
1767             break;
1768
1769         case wxOR_REVERSE:
1770             lCRop = FM_MERGESRCNOT;
1771             break;
1772
1773         case wxAND_REVERSE:
1774             lCRop = FM_NOTMASKSRC;
1775             break;
1776
1777         case wxCLEAR:
1778             lCRop = FM_ONE;
1779             break;
1780
1781         case wxSET:
1782             lCRop = FM_ZERO;
1783             break;
1784
1785         case wxSRC_INVERT:
1786             lCRop = FM_MERGENOTSRC;
1787             break;
1788
1789         case wxOR_INVERT:
1790             lCRop = FM_MERGESRCNOT;
1791             break;
1792
1793         case wxAND:
1794             lCRop = FM_AND;
1795             break;
1796
1797         case wxOR:
1798             lCRop = FM_OR;
1799             break;
1800
1801         case wxAND_INVERT:
1802             lCRop = FM_SUBTRACT;
1803             break;
1804
1805         case wxEQUIV:
1806         case wxNAND:
1807         case wxCOPY:
1808         default:
1809             lCRop = FM_OVERPAINT;
1810             break;
1811     }
1812     ::GpiSetMix((HPS)hDC, lCRop);
1813 } // end of wxDC::SetRop
1814
1815 bool wxDC::StartDoc(
1816   const wxString&                   rsMessage
1817 )
1818 {
1819     // We might be previewing, so return TRUE to let it continue.
1820     return TRUE;
1821 } // end of wxDC::StartDoc
1822
1823 void wxDC::EndDoc()
1824 {
1825 } // end of wxDC::EndDoc
1826
1827 void wxDC::StartPage()
1828 {
1829 } // end of wxDC::StartPage
1830
1831 void wxDC::EndPage()
1832 {
1833 } // end of wxDC::EndPage
1834
1835 // ---------------------------------------------------------------------------
1836 // text metrics
1837 // ---------------------------------------------------------------------------
1838
1839 wxCoord wxDC::GetCharHeight() const
1840 {
1841     FONTMETRICS                     vFM; // metrics structure
1842
1843     ::GpiQueryFontMetrics( m_hPS
1844                           ,sizeof(FONTMETRICS)
1845                           ,&vFM
1846                          );
1847     return YDEV2LOGREL(vFM.lXHeight);
1848 }
1849
1850 wxCoord wxDC::GetCharWidth() const
1851 {
1852     FONTMETRICS                     vFM; // metrics structure
1853
1854     ::GpiQueryFontMetrics( m_hPS
1855                           ,sizeof(FONTMETRICS)
1856                           ,&vFM
1857                          );
1858     return XDEV2LOGREL(vFM.lAveCharWidth);
1859 }
1860
1861 void wxDC::DoGetTextExtent(
1862   const wxString&                   rsString
1863 , wxCoord*                          pvX
1864 , wxCoord*                          pvY
1865 , wxCoord*                          pvDescent
1866 , wxCoord*                          pvExternalLeading
1867 , wxFont*                           pTheFont
1868 ) const
1869 {
1870     POINTL                          avPoint[TXTBOX_COUNT];
1871     POINTL                          vPtMin;
1872     POINTL                          vPtMax;
1873     int                             i;
1874     int                             l;
1875     FONTMETRICS                     vFM; // metrics structure
1876     BOOL                            bRc;
1877     char*                           pStr;
1878     ERRORID                         vErrorCode; // last error id code
1879     wxFont*                         pFontToUse = (wxFont*)pTheFont;
1880
1881     char                            zMsg[128]; // DEBUG
1882     wxString                        sError;
1883
1884     if (!pFontToUse)
1885         pFontToUse = (wxFont*)&m_font;
1886     l = rsString.length();
1887     pStr = (PCH) rsString.c_str();
1888
1889     //
1890     // In world coordinates.
1891     //
1892     bRc = ::GpiQueryTextBox( m_hPS
1893                             ,l
1894                             ,pStr
1895                             ,TXTBOX_COUNT // return maximum information
1896                             ,avPoint      // array of coordinates points
1897                            );
1898     if(!bRc)
1899     {
1900        vErrorCode = ::WinGetLastError(wxGetInstance());
1901        sError = wxPMErrorToStr(vErrorCode);
1902        // DEBUG
1903        sprintf(zMsg, "GpiQueryTextBox for %s: failed with Error: %x - %s", pStr, vErrorCode, sError.c_str());
1904        (void)wxMessageBox( "wxWindows Menu sample"
1905                           ,zMsg
1906                           ,wxICON_INFORMATION
1907                          );
1908     }
1909
1910     vPtMin.x = avPoint[0].x;
1911     vPtMax.x = avPoint[0].x;
1912     vPtMin.y = avPoint[0].y;
1913     vPtMax.y = avPoint[0].y;
1914     for (i = 1; i < 4; i++)
1915     {
1916         if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
1917         if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
1918         if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
1919         if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
1920     }
1921     ::GpiQueryFontMetrics( m_hPS
1922                           ,sizeof(FONTMETRICS)
1923                           ,&vFM
1924                          );
1925
1926     if (pvX)
1927         *pvX = (wxCoord)(vPtMax.x - vPtMin.x + 1);
1928     if (pvY)
1929         *pvY = (wxCoord)(vPtMax.y - vPtMin.y + 1);
1930     if (pvDescent)
1931         *pvDescent = vFM.lMaxDescender;
1932     if (pvExternalLeading)
1933         *pvExternalLeading = vFM.lExternalLeading;
1934 }
1935
1936 void wxDC::SetMapMode(
1937   int                               nMode
1938 )
1939 {
1940     int                             nPixelWidth = 0;
1941     int                             nPixelHeight = 0;
1942     int                             nMmWidth = 1;
1943     int                             nMmHeight = 1;
1944     LONG                            lArray[CAPS_VERTICAL_RESOLUTION];
1945
1946     m_mappingMode = nMode;
1947
1948     if(::DevQueryCaps( m_hDC
1949                       ,CAPS_FAMILY
1950                       ,CAPS_VERTICAL_RESOLUTION
1951                       ,lArray
1952                      ))
1953     {
1954         LONG                        lHorzRes;
1955         LONG                        lVertRes;
1956
1957         nPixelWidth    = lArray[CAPS_WIDTH];
1958         nPixelHeight   = lArray[CAPS_HEIGHT];
1959         lHorzRes  = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
1960         lVertRes  = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
1961         nMmWidth  = (lHorzRes/1000) * nPixelWidth;
1962         nMmWidth = (lVertRes/1000) * nPixelHeight;
1963     }
1964     if ((nPixelWidth == 0) || (nPixelHeight == 0) || (nMmWidth == 0) || (nMmHeight == 0))
1965     {
1966         return;
1967     }
1968
1969     double                          dMm2pixelsX = nPixelWidth/nMmWidth;
1970     double                          dMm2pixelsY = nPixelHeight/nMmHeight;
1971
1972     switch (nMode)
1973     {
1974         case wxMM_TWIPS:
1975             m_logicalScaleX = (twips2mm * dMm2pixelsX);
1976             m_logicalScaleY = (twips2mm * dMm2pixelsY);
1977             break;
1978
1979         case wxMM_POINTS:
1980             m_logicalScaleX = (pt2mm * dMm2pixelsX);
1981             m_logicalScaleY = (pt2mm * dMm2pixelsY);
1982             break;
1983
1984         case wxMM_METRIC:
1985             m_logicalScaleX = dMm2pixelsX;
1986             m_logicalScaleY = dMm2pixelsY;
1987             break;
1988
1989         case wxMM_LOMETRIC:
1990             m_logicalScaleX = (dMm2pixelsX/10.0);
1991             m_logicalScaleY = (dMm2pixelsY/10.0);
1992             break;
1993
1994         case wxMM_TEXT:
1995         default:
1996             m_logicalScaleX = 1.0;
1997             m_logicalScaleY = 1.0;
1998             break;
1999     }
2000     SIZEL                           vSize;
2001     ULONG                           ulOptions;
2002
2003     ulOptions = ::GpiQueryPS(m_hPS, &vSize);
2004     if (!ulOptions & PU_ARBITRARY)
2005     {
2006         ulOptions = PU_ARBITRARY | GPIF_DEFAULT;
2007         ::GpiSetPS(m_hPS, &vSize, ulOptions);
2008     }
2009     m_nWindowExtX = (int)MS_XDEV2LOG(VIEWPORT_EXTENT);
2010     m_nWindowExtY = (int)MS_YDEV2LOG(VIEWPORT_EXTENT);
2011     // ????
2012 }; // end of wxDC::SetMapMode
2013
2014 void wxDC::SetUserScale(
2015   double                            dX
2016 , double                            dY
2017 )
2018 {
2019     m_userScaleX = dX;
2020     m_userScaleY = dY;
2021
2022     SetMapMode(m_mappingMode);
2023 } // end of wxDC::SetUserScale
2024
2025 void wxDC::SetAxisOrientation(
2026   bool                              bXLeftRight
2027 , bool                              bYBottomUp
2028 )
2029 {
2030     m_signX = bXLeftRight ? 1 : -1;
2031     m_signY = bYBottomUp ? -1 : 1;
2032
2033     SetMapMode(m_mappingMode);
2034 } // end of wxDC::SetAxisOrientation
2035
2036 void wxDC::SetSystemScale(
2037   double                            dX
2038 , double                            dY
2039 )
2040 {
2041     m_scaleX = dX;
2042     m_scaleY = dY;
2043
2044     SetMapMode(m_mappingMode);
2045 } // end of wxDC::SetSystemScale
2046
2047 void wxDC::SetLogicalOrigin(
2048   wxCoord                           vX
2049 , wxCoord                           vY
2050 )
2051 {
2052     RECTL                           vRect;
2053
2054     ::GpiQueryPageViewport( m_hPS
2055                            ,&vRect
2056                           );
2057     vRect.xRight -= vX;
2058     vRect.yTop += vY;
2059     vRect.xLeft = vX;
2060     vRect.yBottom = vY;
2061     ::GpiSetPageViewport( m_hPS
2062                          ,&vRect
2063                         );
2064 }; // end of wxDC::SetLogicalOrigin
2065
2066 void wxDC::SetDeviceOrigin(
2067   wxCoord                           vX
2068 , wxCoord                           vY
2069 )
2070 {
2071     RECTL                           vRect;
2072
2073     m_deviceOriginX = vX;
2074     m_deviceOriginY = vY;
2075     ::GpiQueryPageViewport( m_hPS
2076                            ,&vRect
2077                           );
2078     vRect.xLeft += vX;
2079     vRect.xRight += vX;
2080     vRect.yBottom -= vY;
2081     vRect.yTop -= vY;
2082     ::GpiSetPageViewport( m_hPS
2083                          ,&vRect
2084                         );
2085 }; // end of wxDC::SetDeviceOrigin
2086
2087 // ---------------------------------------------------------------------------
2088 // coordinates transformations
2089 // ---------------------------------------------------------------------------
2090
2091 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
2092 {
2093     return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
2094 }
2095
2096 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
2097 {
2098         // axis orientation is not taken into account for conversion of a distance
2099     return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_scaleX));
2100 }
2101
2102 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
2103 {
2104     return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
2105 }
2106
2107 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
2108 {
2109         // axis orientation is not taken into account for conversion of a distance
2110     return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_scaleY));
2111 }
2112
2113 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
2114 {
2115     return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
2116 }
2117
2118 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
2119 {
2120         // axis orientation is not taken into account for conversion of a distance
2121     return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
2122 }
2123
2124 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
2125 {
2126     return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
2127 }
2128
2129 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
2130 {
2131         // axis orientation is not taken into account for conversion of a distance
2132     return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
2133 }
2134
2135 // ---------------------------------------------------------------------------
2136 // bit blit
2137 // ---------------------------------------------------------------------------
2138
2139 bool wxDC::DoBlit(
2140   wxCoord                           vXdest
2141 , wxCoord                           vYdest
2142 , wxCoord                           vWidth
2143 , wxCoord                           vHeight
2144 , wxDC*                             pSource
2145 , wxCoord                           vXsrc
2146 , wxCoord                           vYsrc
2147 , int                               nRop
2148 , bool                              bUseMask
2149 , wxCoord                           vXsrcMask
2150 , wxCoord                           vYsrcMask
2151 )
2152 {
2153     wxMask*                         pMask = NULL;
2154     CHARBUNDLE                      vCbnd;
2155     COLORREF                        vOldTextColor;
2156     COLORREF                        vOldBackground = ::GpiQueryBackColor(m_hPS);
2157
2158     if (bUseMask)
2159     {
2160         const wxBitmap&             rBmp = pSource->m_vSelectedBitmap;
2161
2162         pMask = rBmp.GetMask();
2163         if (!(rBmp.Ok() && pMask && pMask->GetMaskBitmap()))
2164         {
2165             bUseMask = FALSE;
2166         }
2167     }
2168
2169     ::GpiQueryAttrs( m_hPS
2170                     ,PRIM_CHAR
2171                     ,CBB_COLOR
2172                     ,&vCbnd
2173                    );
2174     vOldTextColor = (COLORREF)vCbnd.lColor;
2175
2176     if (m_textForegroundColour.Ok())
2177     {
2178         vCbnd.lColor = (LONG)m_textForegroundColour.GetPixel();
2179         ::GpiSetAttrs( m_hPS           // presentation-space handle
2180                       ,PRIM_CHAR       // Char primitive.
2181                       ,CBB_COLOR       // sets color.
2182                       ,0
2183                       ,&vCbnd          // buffer for attributes.
2184                      );
2185     }
2186     if (m_textBackgroundColour.Ok())
2187     {
2188         ::GpiSetBackColor(m_hPS, (LONG)m_textBackgroundColour.GetPixel());
2189     }
2190
2191     LONG                            lRop = ROP_SRCCOPY;
2192
2193     switch (nRop)
2194     {
2195         case wxXOR:          lRop = ROP_SRCINVERT;        break;
2196         case wxINVERT:       lRop = ROP_DSTINVERT;        break;
2197         case wxOR_REVERSE:   lRop = 0x00DD0228;           break;
2198         case wxAND_REVERSE:  lRop = ROP_SRCERASE;         break;
2199         case wxCLEAR:        lRop = ROP_ZERO;             break;
2200         case wxSET:          lRop = ROP_ONE;              break;
2201         case wxOR_INVERT:    lRop = ROP_MERGEPAINT;       break;
2202         case wxAND:          lRop = ROP_SRCAND;           break;
2203         case wxOR:           lRop = ROP_SRCPAINT;         break;
2204         case wxEQUIV:        lRop = 0x00990066;           break;
2205         case wxNAND:         lRop = 0x007700E6;           break;
2206         case wxAND_INVERT:   lRop = 0x00220326;           break;
2207         case wxCOPY:         lRop = ROP_SRCCOPY;          break;
2208         case wxNO_OP:        lRop = ROP_NOTSRCERASE;      break;
2209         case wxSRC_INVERT:   lRop = ROP_SRCINVERT;        break;
2210         case wxNOR:          lRop = ROP_NOTSRCCOPY;       break;
2211         default:
2212            wxFAIL_MSG( wxT("unsupported logical function") );
2213            return FALSE;
2214     }
2215
2216     bool                            bSuccess;
2217
2218     if (bUseMask)
2219     {
2220         //
2221         // Blit bitmap with mask
2222         //
2223
2224         //
2225         // Create a temp buffer bitmap and DCs/PSs to access it and the mask
2226         //
2227         HDC                             hDCMask;
2228         HDC                             hDCBuffer;
2229         HPS                             hPSMask;
2230         HPS                             hPSBuffer;
2231         DEVOPENSTRUC                    vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
2232         BITMAPINFOHEADER2               vBmpHdr;
2233         HBITMAP                         hBufBitmap;
2234         SIZEL                           vSize = {0, 0};
2235         LONG                            rc;
2236
2237         memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
2238         vBmpHdr.cbFix     = sizeof(BITMAPINFOHEADER2);
2239         vBmpHdr.cx        = vWidth;
2240         vBmpHdr.cy        = vHeight;
2241         vBmpHdr.cPlanes   = 1;
2242         vBmpHdr.cBitCount = 24;
2243
2244 #if wxUSE_DC_CACHEING
2245         if (TRUE)
2246         {
2247             //
2248             // create a temp buffer bitmap and DCs to access it and the mask
2249             //
2250             wxDCCacheEntry*         pDCCacheEntry1    = FindDCInCache( NULL
2251                                                                       ,pSource->GetHPS()
2252                                                                      );
2253             wxDCCacheEntry*         pDCCacheEntry2    = FindDCInCache( pDCCacheEntry1
2254                                                                       ,GetHPS()
2255                                                                      );
2256             wxDCCacheEntry*         pBitmapCacheEntry = FindBitmapInCache( GetHPS()
2257                                                                           ,vWidth
2258                                                                           ,vHeight
2259                                                                          );
2260
2261             hPSMask = pDCCacheEntry1->m_hPS;
2262             hDCBuffer = (HDC)pDCCacheEntry2->m_hPS;
2263             hBufBitmap = (HBITMAP)pBitmapCacheEntry->m_hBitmap;
2264         }
2265         else
2266 #endif
2267         {
2268             hDCMask = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
2269             hDCBuffer = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
2270             hPSMask = ::GpiCreatePS(vHabmain, hDCMask, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
2271             hPSBuffer = ::GpiCreatePS(vHabmain, hDCBuffer, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
2272             hBufBitmap = ::GpiCreateBitmap(GetHPS(), &vBmpHdr, 0L, NULL, NULL);
2273         }
2274
2275         POINTL                          aPoint1[4] = { 0, 0
2276                                                       ,vWidth, vHeight
2277                                                       ,vXdest, vYdest
2278                                                       ,vXdest + vWidth, vYdest + vHeight
2279                                                      };
2280         POINTL                          aPoint2[4] = { 0, 0
2281                                                       ,vWidth, vHeight
2282                                                       ,vXsrc, vYsrc
2283                                                       ,vXsrc + vWidth, vYsrc + vHeight
2284                                                      };
2285         POINTL                          aPoint3[4] = { vXdest, vYdest
2286                                                       ,vXdest + vWidth, vYdest + vHeight
2287                                                       ,vXsrc, vYsrc
2288                                                       ,vXsrc + vWidth, vYsrc + vHeight
2289                                                      };
2290         POINTL                          aPoint4[4] = { vXdest, vYdest
2291                                                       ,vXdest + vWidth, vYdest + vHeight
2292                                                       ,0, 0
2293                                                       ,vWidth, vHeight
2294                                                      };
2295         ::GpiSetBitmap(hPSMask, (HBITMAP) pMask->GetMaskBitmap());
2296         ::GpiSetBitmap(hPSBuffer, (HBITMAP) hBufBitmap);
2297
2298         //
2299         // Copy dest to buffer
2300         //
2301         rc = ::GpiBitBlt( hPSBuffer
2302                          ,GetHPS()
2303                          ,4L
2304                          ,aPoint1
2305                          ,ROP_SRCCOPY
2306                          ,BBO_IGNORE
2307                         );
2308         if (rc == GPI_ERROR)
2309         {
2310             wxLogLastError(wxT("BitBlt"));
2311         }
2312
2313         //
2314         // Copy src to buffer using selected raster op
2315         //
2316         rc = ::GpiBitBlt( hPSBuffer
2317                          ,GetHPS()
2318                          ,4L
2319                          ,aPoint2
2320                          ,lRop
2321                          ,BBO_IGNORE
2322                         );
2323         if (rc == GPI_ERROR)
2324         {
2325             wxLogLastError(wxT("BitBlt"));
2326         }
2327
2328         //
2329         // Set masked area in buffer to BLACK (pixel value 0)
2330         //
2331         COLORREF                        vPrevBkCol = ::GpiQueryBackColor(GetHPS());
2332         COLORREF                        vPrevCol = ::GpiQueryColor(GetHPS());
2333
2334         ::GpiSetBackColor(GetHPS(), OS2RGB(255, 255, 255));
2335         ::GpiSetColor(GetHPS(), OS2RGB(0, 0, 0));
2336
2337         rc = ::GpiBitBlt( hPSBuffer
2338                          ,hPSMask
2339                          ,4L
2340                          ,aPoint2
2341                          ,ROP_SRCAND
2342                          ,BBO_IGNORE
2343                         );
2344         if (rc == GPI_ERROR)
2345         {
2346             wxLogLastError(wxT("BitBlt"));
2347         }
2348
2349         //
2350         // Set unmasked area in dest to BLACK
2351         //
2352         ::GpiSetBackColor(GetHPS(), OS2RGB(0, 0, 0));
2353         ::GpiSetColor(GetHPS(), OS2RGB(255, 255, 255));
2354         rc = ::GpiBitBlt( GetHPS()
2355                          ,hPSMask
2356                          ,4L
2357                          ,aPoint3
2358                          ,ROP_SRCAND
2359                          ,BBO_IGNORE
2360                         );
2361         if (rc == GPI_ERROR)
2362         {
2363             wxLogLastError(wxT("BitBlt"));
2364         }
2365
2366         //
2367         // Restore colours to original values
2368         //
2369         ::GpiSetBackColor(GetHPS(), vPrevBkCol);
2370         ::GpiSetColor(GetHPS(), vPrevCol);
2371
2372         //
2373         // OR buffer to dest
2374         //
2375         rc = ::GpiBitBlt( GetHPS()
2376                          ,hPSMask
2377                          ,4L
2378                          ,aPoint4
2379                          ,ROP_SRCPAINT
2380                          ,BBO_IGNORE
2381                         );
2382         if (rc == GPI_ERROR)
2383         {
2384             bSuccess = FALSE;
2385             wxLogLastError(wxT("BitBlt"));
2386         }
2387
2388         //
2389         // Tidy up temporary DCs and bitmap
2390         //
2391         ::GpiSetBitmap(hPSMask, NULLHANDLE);
2392         ::GpiSetBitmap(hPSBuffer, NULLHANDLE);
2393 #if !wxUSE_DC_CACHEING
2394         ::GpiDestroyPS(hPSMask);
2395         ::GpiDestroyPS(hPSBuffer);
2396         ::DevCloseDC(hDCMask);
2397         ::DevCloseDC(hDCBuffer);
2398         ::GpiDeleteBitmap(hBufBitmap);
2399 #endif
2400         bSuccess = TRUE;
2401     }
2402     else // no mask, just BitBlt() it
2403     {
2404         POINTL                          aPoint[4] = { vXdest, vYdest
2405                                                      ,vXdest + vWidth, vYdest + vHeight
2406                                                      ,vXsrc, vYsrc
2407                                                      ,vXsrc + vWidth, vYsrc + vHeight
2408                                                     };
2409
2410         bSuccess = (::GpiBitBlt( m_hPS
2411                                 ,pSource->GetHPS()
2412                                 ,4L
2413                                 ,aPoint
2414                                 ,lRop
2415                                 ,BBO_IGNORE
2416                                ) != GPI_ERROR);
2417         if (!bSuccess )
2418         {
2419             wxLogLastError(wxT("BitBlt"));
2420         }
2421     }
2422     vCbnd.lColor = (LONG)vOldTextColor;
2423     ::GpiSetAttrs( m_hPS           // presentation-space handle
2424                   ,PRIM_CHAR       // Char primitive.
2425                   ,CBB_COLOR       // sets color.
2426                   ,0
2427                   ,&vCbnd          // buffer for attributes.
2428                  );
2429     ::GpiSetBackColor(m_hPS, (LONG)vOldBackground);
2430     return bSuccess;
2431 }
2432
2433 void wxDC::DoGetSize(
2434   int*                              pnWidth
2435 , int*                              pnHeight
2436 ) const
2437 {
2438     LONG                            lArray[CAPS_HEIGHT];
2439
2440     if(::DevQueryCaps( m_hDC
2441                       ,CAPS_FAMILY
2442                       ,CAPS_HEIGHT
2443                       ,lArray
2444                      ))
2445     {
2446         *pnWidth  = lArray[CAPS_WIDTH];
2447         *pnHeight = lArray[CAPS_HEIGHT];
2448     }
2449 }; // end of wxDC::DoGetSize(
2450
2451 void wxDC::DoGetSizeMM(
2452   int*                              pnWidth
2453 , int*                              pnHeight
2454 ) const
2455 {
2456     LONG                            lArray[CAPS_VERTICAL_RESOLUTION];
2457
2458     if(::DevQueryCaps( m_hDC
2459                       ,CAPS_FAMILY
2460                       ,CAPS_VERTICAL_RESOLUTION
2461                       ,lArray
2462                      ))
2463     {
2464         int                         nWidth;
2465         int                         nHeight;
2466         int                         nHorzRes;
2467         int                         nVertRes;
2468
2469         nWidth    = lArray[CAPS_WIDTH];
2470         nHeight   = lArray[CAPS_HEIGHT];
2471         nHorzRes  = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
2472         nVertRes  = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
2473         nWidth  = (nHorzRes/1000) * nWidth;
2474         nHeight = (nVertRes/1000) * nHeight;
2475     }
2476 }; // end of wxDC::DoGetSizeMM
2477
2478 wxSize wxDC::GetPPI() const
2479 {
2480     LONG                            lArray[CAPS_VERTICAL_RESOLUTION];
2481     int                             nWidth;
2482     int                             nHeight;
2483
2484     if(::DevQueryCaps( m_hDC
2485                       ,CAPS_FAMILY
2486                       ,CAPS_VERTICAL_RESOLUTION
2487                       ,lArray
2488                      ))
2489     {
2490         int                         nPelWidth;
2491         int                         nPelHeight;
2492         int                         nHorzRes;
2493         int                         nVertRes;
2494
2495         nPelWidth  = lArray[CAPS_WIDTH];
2496         nPelHeight = lArray[CAPS_HEIGHT];
2497         nHorzRes   = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
2498         nVertRes   = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
2499         nWidth   = (nHorzRes/39.3) * nPelWidth;
2500         nHeight  = (nVertRes/39.3) * nPelHeight;
2501     }
2502     return (wxSize(nWidth,nHeight));
2503 } // end of wxDC::GetPPI
2504
2505 void wxDC::SetLogicalScale(
2506   double                            dX
2507 , double                            dY
2508 )
2509 {
2510     m_logicalScaleX = dX;
2511     m_logicalScaleY = dY;
2512 }; // end of wxDC::SetLogicalScale
2513
2514 #if WXWIN_COMPATIBILITY
2515 void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
2516                          float *descent, float *externalLeading,
2517                          wxFont *theFont, bool use16bit) const
2518 {
2519     wxCoord x1, y1, descent1, externalLeading1;
2520     GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
2521     *x = x1; *y = y1;
2522     if (descent)
2523         *descent = descent1;
2524     if (externalLeading)
2525         *externalLeading = externalLeading1;
2526 }
2527 #endif
2528