/////////////////////////////////////////////////////////////////////////////
// Name:        src/os2/dc.cpp
// Purpose:     wxDC class
// Author:      David Webster
// Modified by:
// Created:     10/14/99
// Copyright:   (c) David Webster
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifndef WX_PRECOMP
    #include "wx/window.h"
    #include "wx/dc.h"
    #include "wx/utils.h"
    #include "wx/dialog.h"
    #include "wx/app.h"
    #include "wx/bitmap.h"
    #include "wx/dcmemory.h"
    #include "wx/log.h"
    #include "wx/icon.h"
    #include "wx/msgdlg.h"
    #include "wx/dcprint.h"
    #include "wx/statusbr.h"
    #include "wx/module.h"
#endif

#include <string.h>

#include "wx/os2/dc.h"
#include "wx/os2/dcclient.h"
#include "wx/os2/private.h"

IMPLEMENT_ABSTRACT_CLASS(wxPMDCImpl, wxDCImpl)

//
// wxWidgets uses the Microsoft convention that the origin is the UPPER left.
// Native OS/2 however in the GPI and PM define the origin as the LOWER left.
// In order to map OS/2 GPI/PM y coordinates to wxWidgets coordinates we must
// perform the following transformation:
//
// Parent object height:     POBJHEIGHT
// Desried origin:           WXORIGINY
// Object to place's height: OBJHEIGHT
//
// To get the OS2 position from the wxWidgets one:
//
// OS2Y = POBJHEIGHT - (WXORIGINY + OBJHEIGHT)
//
// For OS/2 wxDC's we will always determine m_vRclPaint as the size of the
// OS/2 Presentation Space associated with the device context.  y is the
// desired application's y coordinate of the origin in wxWidgets space.
// objy is the height of the object we are going to draw.
//
#define OS2Y(y, objy) ((m_vRclPaint.yTop - m_vRclPaint.yBottom) - (y + objy))

// ---------------------------------------------------------------------------
// constants
// ---------------------------------------------------------------------------

static const int VIEWPORT_EXTENT = 1000;

static const int MM_POINTS = 9;
static const int MM_METRIC = 10;

// ---------------------------------------------------------------------------
// private functions
// ---------------------------------------------------------------------------

// convert degrees to radians
static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }

int SetTextColor(
  HPS                               hPS
, int                               nForegroundColour
)
{
    CHARBUNDLE                      vCbnd;

    vCbnd.lColor =  nForegroundColour;
    ::GpiSetAttrs( hPS       // presentation-space handle
                  ,PRIM_CHAR // Char primitive.
                  ,CBB_COLOR // sets color.
                  ,0         //
                  ,&vCbnd    // buffer for attributes.
                 );
    return 0;
}

int QueryTextBkColor(
  HPS                               hPS
)
{
    CHARBUNDLE                      vCbnd;

    ::GpiQueryAttrs( hPS            // presentation-space handle
                    ,PRIM_CHAR      // Char primitive.
                    ,CBB_BACK_COLOR // Background color.
                    ,&vCbnd         // buffer for attributes.
                   );
    return vCbnd.lBackColor;
}


int SetTextBkColor(
  HPS                               hPS
, int                               nBackgroundColour
)
{
    CHARBUNDLE                      vCbnd;
    int                             rc;

    rc =  QueryTextBkColor(hPS);

    vCbnd.lBackColor = nBackgroundColour;
    ::GpiSetAttrs(hPS,            // presentation-space handle
                  PRIM_CHAR,      // Char primitive.
                  CBB_BACK_COLOR, // sets color.
                  0,
                  &vCbnd          // buffer for attributes.
                 );
    return rc;
}

int SetBkMode(
  HPS                               hPS
, int                               nBackgroundMode
)
{
    if(nBackgroundMode == wxTRANSPARENT)
        ::GpiSetBackMix( hPS
                        ,BM_LEAVEALONE
                       );
    else
        // the background of the primitive takes  over whatever is underneath.
        ::GpiSetBackMix( hPS
                        ,BM_OVERPAINT
                        );
    return 0;
}

// ===========================================================================
// implementation
// ===========================================================================

#if wxUSE_DC_CACHEING

/*
 * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
 * improve it in due course, either using arrays, or simply storing pointers to one
 * entry for the bitmap, and two for the DCs. -- JACS
 */

// ---------------------------------------------------------------------------
// wxDCCacheEntry
// ---------------------------------------------------------------------------

wxList wxPMDCImpl::m_svBitmapCache;
wxList wxPMDCImpl::m_svDCCache;

wxDCCacheEntry::wxDCCacheEntry(
  WXHBITMAP                         hBitmap
, int                               nWidth
, int                               nHeight
, int                               nDepth
)
{
    m_hBitmap = hBitmap;
    m_hPS     = NULLHANDLE;
    m_nWidth  = nWidth;
    m_nHeight = nHeight;
    m_nDepth  = nDepth;
} // end of wxDCCacheEntry::wxDCCacheEntry

wxDCCacheEntry::wxDCCacheEntry(
  HPS                               hPS
, int                               nDepth
)
{
    m_hBitmap = NULLHANDLE;
    m_hPS     = hPS;
    m_nWidth  = 0;
    m_nHeight = 0;
    m_nDepth  = nDepth;
} // end of wxDCCacheEntry::wxDCCacheEntry

wxDCCacheEntry::~wxDCCacheEntry()
{
    if (m_hBitmap)
        ::GpiDeleteBitmap(m_hBitmap);
    if (m_hPS)
        ::GpiDestroyPS(m_hPS);
} // end of wxDCCacheEntry::~wxDCCacheEntry

wxDCCacheEntry* wxPMDCImpl::FindBitmapInCache(
  HPS                               hPS
, int                               nWidth
, int                               nHeight
)
{
    int                             nDepth = 24; // we'll fix this later ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
    wxNode*                         pNode = m_svBitmapCache.First();
    BITMAPINFOHEADER2               vBmpHdr;

    while(pNode)
    {
        wxDCCacheEntry*             pEntry = (wxDCCacheEntry*)pNode->Data();

        if (pEntry->m_nDepth == nDepth)
        {
            memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));

            if (pEntry->m_nWidth < nWidth || pEntry->m_nHeight < nHeight)
            {
                ::GpiDeleteBitmap((HBITMAP)pEntry->m_hBitmap);
                vBmpHdr.cbFix     = sizeof(BITMAPINFOHEADER2);
                vBmpHdr.cx        = nWidth;
                vBmpHdr.cy        = nHeight;
                vBmpHdr.cPlanes   = 1;
                vBmpHdr.cBitCount = (USHORT)nDepth;

                pEntry->m_hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
                                                                  ,&vBmpHdr
                                                                  ,0L, NULL, NULL
                                                                 );
                if (!pEntry->m_hBitmap)
                {
                    wxLogLastError(wxT("CreateCompatibleBitmap"));
                }
                pEntry->m_nWidth  = nWidth;
                pEntry->m_nHeight = nHeight;
                return pEntry;
            }
            return pEntry;
        }
        pNode = pNode->Next();
    }
    memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
    vBmpHdr.cbFix     = sizeof(BITMAPINFOHEADER2);
    vBmpHdr.cx        = nWidth;
    vBmpHdr.cy        = nHeight;
    vBmpHdr.cPlanes   = 1;
    vBmpHdr.cBitCount = (USHORT)nDepth;

    WXHBITMAP                       hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
                                                                            ,&vBmpHdr
                                                                            ,0L, NULL, NULL
                                                                           );
    if (!hBitmap)
    {
        wxLogLastError(wxT("CreateCompatibleBitmap"));
    }
    wxDCCacheEntry*                 pEntry = new wxDCCacheEntry( hBitmap
                                                                ,nWidth
                                                                ,nHeight
                                                                ,nDepth
                                                               );
    AddToBitmapCache(pEntry);
    return pEntry;
} // end of FindBitmapInCache

wxDCCacheEntry* wxPMDCImpl::FindDCInCache(
  wxDCCacheEntry*                   pNotThis
, HPS                               hPS
)
{
    int                             nDepth = 24; // we'll fix this up later ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
    wxNode*                         pNode = m_svDCCache.First();

    while(pNode)
    {
        wxDCCacheEntry*             pEntry = (wxDCCacheEntry*)pNode->Data();

        //
        // Don't return the same one as we already have
        //
        if (!pNotThis || (pNotThis != pEntry))
        {
            if (pEntry->m_nDepth == nDepth)
            {
                return pEntry;
            }
        }
        pNode = pNode->Next();
    }
    wxDCCacheEntry*                 pEntry = new wxDCCacheEntry( hPS
                                                                ,nDepth
                                                               );
    AddToDCCache(pEntry);
    return pEntry;
} // end of wxPMDCImpl::FindDCInCache

void wxPMDCImpl::AddToBitmapCache(
  wxDCCacheEntry*                   pEntry
)
{
    m_svBitmapCache.Append(pEntry);
} // end of wxPMDCImpl::AddToBitmapCache

void wxPMDCImpl::AddToDCCache(
  wxDCCacheEntry*                   pEntry
)
{
    m_svDCCache.Append(pEntry);
} // end of wxPMDCImpl::AddToDCCache

void wxPMDCImpl::ClearCache()
{
    m_svBitmapCache.DeleteContents(true);
    m_svBitmapCache.Clear();
    m_svBitmapCache.DeleteContents(false);
    m_svDCCache.DeleteContents(true);
    m_svDCCache.Clear();
    m_svDCCache.DeleteContents(false);
} // end of wxPMDCImpl::ClearCache

// Clean up cache at app exit
class wxDCModule : public wxModule
{
public:
    virtual bool OnInit() { return true; }
    virtual void OnExit() { wxPMDCImpl::ClearCache(); }

private:
    DECLARE_DYNAMIC_CLASS(wxDCModule)
}; // end of CLASS wxDCModule

IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)

#endif // ndef for wxUSE_DC_CACHEING

// ---------------------------------------------------------------------------
// wxDC
// ---------------------------------------------------------------------------

wxPMDCImpl::wxPMDCImpl( wxDC *owner, WXHDC hDC ) :
    wxDCImpl( owner )
{
    Init();
    m_hDC          = hDC;
} // end of wxPMDCImpl::wxPMDCImpl

wxPMDCImpl::~wxPMDCImpl()
{
    if ( m_hDC != 0 )
    {
        SelectOldObjects(m_hDC);

        // if we own the HDC, we delete it, otherwise we just release it

        if (m_bOwnsDC)
        {
            if(m_hPS)
            {
                ::GpiAssociate(m_hPS, NULLHANDLE);
                ::GpiDestroyPS(m_hPS);
            }
            m_hPS = NULLHANDLE;
            ::DevCloseDC((HDC)m_hDC);
        }
        else
        {
            //
            // Just Dissacociate, not destroy if we don't own the DC
            //
            if(m_hPS)
            {
                ::GpiAssociate(m_hPS, NULLHANDLE);
            }
        }
    }
} // end of wxPMDCImpl::~wxDC

// This will select current objects out of the DC,
// which is what you have to do before deleting the
// DC.
void wxPMDCImpl::SelectOldObjects(
  WXHDC                             hPS
)
{
    if (hPS)
    {
        if (m_hOldBitmap)
        {
            ::GpiSetBitmap(hPS, (HBITMAP) m_hOldBitmap);
            if (m_vSelectedBitmap.IsOk())
            {
                m_vSelectedBitmap.SetSelectedInto(NULL);
            }
        }
        m_hOldBitmap = 0;
        //
        // OS/2 has no other native GDI objects to set in a PS/DC like windows
        //
        m_hOldPen = 0;
        m_hOldBrush = 0;
        m_hOldFont = 0;
        m_hOldPalette = 0;
    }

    m_brush           = wxNullBrush;
    m_pen             = wxNullPen;
    m_palette         = wxNullPalette;
    m_font            = wxNullFont;
    m_backgroundBrush = wxNullBrush;
    m_vSelectedBitmap = wxNullBitmap;
} // end of wxPMDCImpl::SelectOldObjects

// ---------------------------------------------------------------------------
// clipping
// ---------------------------------------------------------------------------

#define DO_SET_CLIPPING_BOX()                    \
{                                                \
    RECTL rect;                                  \
                                                 \
    ::GpiQueryClipBox(m_hPS, &rect);             \
                                                 \
    m_clipX1 = (wxCoord) XDEV2LOG(rect.xLeft);   \
    m_clipY1 = (wxCoord) YDEV2LOG(rect.yTop);    \
    m_clipX2 = (wxCoord) XDEV2LOG(rect.xRight);  \
    m_clipY2 = (wxCoord) YDEV2LOG(rect.yBottom); \
}

void wxPMDCImpl::DoSetClippingRegion(
  wxCoord                           vX
, wxCoord                           vY
, wxCoord                           vWidth
, wxCoord                           vHeight
)
{
    RECTL                           vRect;

    vY = OS2Y(vY,vHeight);
    m_clipping    = true;
    vRect.xLeft   = vX;
    vRect.yTop    = vY + vHeight;
    vRect.xRight  = vX + vWidth;
    vRect.yBottom = vY;
    ::GpiIntersectClipRectangle(m_hPS, &vRect);
    DO_SET_CLIPPING_BOX()
} // end of wxPMDCImpl::DoSetClippingRegion

void wxPMDCImpl::DoSetDeviceClippingRegion(
  const wxRegion&                   rRegion
)
{
     wxCHECK_RET(rRegion.GetHRGN(), wxT("invalid clipping region"));
     HRGN                           hRgnOld;

     m_clipping = true;
     ::GpiSetClipRegion( m_hPS
                        ,(HRGN)rRegion.GetHRGN()
                        ,&hRgnOld
                       );
    DO_SET_CLIPPING_BOX()
} // end of wxPMDCImpl::DoSetDeviceClippingRegion

void wxPMDCImpl::DestroyClippingRegion()
{
    if (m_clipping && m_hPS)
    {
         HRGN                       hRgnOld;
         RECTL                      vRect;

         // TODO: this should restore the previous clipped region
         //       so that OnPaint processing works correctly, and
         //       the update doesn't get destroyed after the first
         //       DestroyClippingRegion
         vRect.xLeft   = XLOG2DEV(0);
         vRect.yTop    = YLOG2DEV(32000);
         vRect.xRight  = XLOG2DEV(32000);
         vRect.yBottom = YLOG2DEV(0);

         HRGN                       hRgn = ::GpiCreateRegion(m_hPS, 1, &vRect);

         ::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
     }
    ResetClipping();
} // end of wxPMDCImpl::DestroyClippingRegion

// ---------------------------------------------------------------------------
// query capabilities
// ---------------------------------------------------------------------------

bool wxPMDCImpl::CanDrawBitmap() const
{
    return true;
}

bool wxPMDCImpl::CanGetTextExtent() const
{
    LONG                            lTechnology = 0L;

    ::DevQueryCaps(GetHDC(), CAPS_TECHNOLOGY, 1L, &lTechnology);
    return (lTechnology == CAPS_TECH_RASTER_DISPLAY) || (lTechnology == CAPS_TECH_RASTER_PRINTER);
} // end of wxPMDCImpl::CanGetTextExtent

int wxPMDCImpl::GetDepth() const
{
    LONG                            lCapsColorBitcount;
    int                             nBitsPerPixel = 0;

    if(::DevQueryCaps( GetHDC()
                      ,CAPS_COLOR_BITCOUNT
                      ,1L
                      ,&lCapsColorBitcount
                     ))
    {
        nBitsPerPixel = (int)lCapsColorBitcount;
    }
    return nBitsPerPixel;
} // end of wxPMDCImpl::GetDepth

// ---------------------------------------------------------------------------
// drawing
// ---------------------------------------------------------------------------

void wxPMDCImpl::Clear()
{
    //
    // If this is a canvas DC then just fill with the background color
    // Otherwise purge the whole thing
    //
    if (m_pCanvas)
    {
        RECTL                       vRect;

        ::GpiQueryClipBox(m_hPS, &vRect);
        ::WinFillRect(m_hPS, &vRect, ::GpiQueryBackColor(m_hPS));
    }
    else
    ::GpiErase(m_hPS);
} // end of wxPMDCImpl::Clear

bool wxPMDCImpl::DoFloodFill(
  wxCoord                           vX
, wxCoord                           vY
, const wxColour&                   rCol
, wxFloodFillStyle                  nStyle
)
{
    POINTL                          vPtlPos;
    LONG                            lColor;
    LONG                            lOptions;
    LONG                            lHits;
    bool                            bSuccess = false;

    vPtlPos.x = vX;             // Loads x-coordinate
    vPtlPos.y = OS2Y(vY,0);     // Loads y-coordinate
    ::GpiMove(m_hPS, &vPtlPos); // Sets current position
    lColor = rCol.GetPixel();
    lOptions = FF_BOUNDARY;
    if(wxFLOOD_SURFACE == nStyle)
        lOptions = FF_SURFACE;

    if ((lHits = ::GpiFloodFill(m_hPS, lOptions, lColor)) != GPI_ERROR)
        bSuccess = true;

    return bSuccess;
} // end of wxPMDCImpl::DoFloodFill

bool wxPMDCImpl::DoGetPixel(
  wxCoord                           vX
, wxCoord                           vY
, wxColour*                         pCol
) const
{
    POINTL                          vPoint;
    LONG                            lColor;

    vPoint.x = vX;
    vPoint.y = OS2Y(vY,0);
    lColor = ::GpiQueryPel(m_hPS, &vPoint);

    //
    // return the color of the pixel
    //
    if(pCol)
        pCol->Set( GetRValue(lColor)
                  ,GetGValue(lColor)
                  ,GetBValue(lColor)
                 );
    return true;
} // end of wxPMDCImpl::DoGetPixel

void wxPMDCImpl::DoCrossHair(
  wxCoord                           vX
, wxCoord                           vY
)
{
    vY = OS2Y(vY,0);

    wxCoord                         vX1 = vX - VIEWPORT_EXTENT;
    wxCoord                         vY1 = vY - VIEWPORT_EXTENT;
    wxCoord                         vX2 = vX + VIEWPORT_EXTENT;
    wxCoord                         vY2 = vY + VIEWPORT_EXTENT;
    POINTL                          vPoint[4];

    vPoint[0].x = vX1;
    vPoint[0].y = vY;

    vPoint[1].x = vX2;
    vPoint[1].y = vY;

    ::GpiMove(m_hPS, &vPoint[0]);
    ::GpiLine(m_hPS, &vPoint[1]);

    vPoint[2].x = vX;
    vPoint[2].y = vY1;

    vPoint[3].x = vX;
    vPoint[3].y = vY2;

    ::GpiMove(m_hPS, &vPoint[2]);
    ::GpiLine(m_hPS, &vPoint[3]);
    CalcBoundingBox(vX1, vY1);
    CalcBoundingBox(vX2, vY2);
} // end of wxPMDCImpl::DoCrossHair

void wxPMDCImpl::DoDrawLine(
  wxCoord                           vX1
, wxCoord                           vY1
, wxCoord                           vX2
, wxCoord                           vY2
)
{
    POINTL                          vPoint[2];
    COLORREF                        vColor = 0x00ffffff;

    //
    // Might be a memory DC with no Paint rect.
    //
    if (!(m_vRclPaint.yTop == 0 &&
          m_vRclPaint.yBottom == 0 &&
          m_vRclPaint.xRight == 0 &&
          m_vRclPaint.xLeft == 0))
    {
        vY1 = OS2Y(vY1,0);
        vY2 = OS2Y(vY2,0);
    }
    else
    {
        if (m_vSelectedBitmap.IsOk())
        {
            m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
            m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
            vY1 = OS2Y(vY1,0);
            vY2 = OS2Y(vY2,0);
        }
    }
    vPoint[0].x = vX1;
    vPoint[0].y = vY1;
    vPoint[1].x = vX2;
    vPoint[1].y = vY2;
    if (m_pen.IsOk())
    {
        vColor = m_pen.GetColour().GetPixel();
    }
    ::GpiSetColor(m_hPS, vColor);
    ::GpiMove(m_hPS, &vPoint[0]);
    ::GpiLine(m_hPS, &vPoint[1]);
    CalcBoundingBox(vX1, vY1);
    CalcBoundingBox(vX2, vY2);
} // end of wxPMDCImpl::DoDrawLine

//////////////////////////////////////////////////////////////////////////////
// Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
// and ending at (x2, y2). The current pen is used for the outline and the
// current brush for filling the shape. The arc is drawn in an anticlockwise
// direction from the start point to the end point.
//////////////////////////////////////////////////////////////////////////////
void wxPMDCImpl::DoDrawArc(
  wxCoord                           vX1
, wxCoord                           vY1
, wxCoord                           vX2
, wxCoord                           vY2
, wxCoord                           vXc
, wxCoord                           vYc
)
{
     POINTL                         vPtlPos;
     POINTL                         vPtlArc[2]; // Structure for current position
     double                         dRadius;
     double                         dAngl1;
     double                         dAngl2;
     double                         dAnglmid;
     wxCoord                        vXm;
     wxCoord                        vYm;
     ARCPARAMS                      vArcp; // Structure for arc parameters

    if((vX1 == vXc && vY1 == vXc) || (vX2 == vXc && vY2 == vXc))
        return; // Draw point ??
    dRadius = 0.5 * ( hypot( (double)(vY1 - vYc)
                            ,(double)(vX1 - vXc)
                           ) +
                      hypot( (double)(vY2 - vYc)
                            ,(double)(vX2 - vXc)
                           )
                     );

    dAngl1 = atan2( (double)(vY1 - vYc)
                   ,(double)(vX1 - vXc)
                  );
    dAngl2 = atan2( (double)(vY2 - vYc)
                   ,(double)(vX2 - vXc)
                  );
    if(dAngl2 < dAngl1)
        dAngl2 += M_PI * 2;

    //
    // GpiPointArc can't draw full arc
    //
     if(dAngl2 == dAngl1 || (vX1 == vX2 && vY1 == vY2) )
     {
        //
        // Medium point
        //
        dAnglmid = (dAngl1 + dAngl2)/2. + M_PI;
        vXm      = (wxCoord)(vXc + dRadius * cos(dAnglmid));
        vYm      = (wxCoord)(vYc + dRadius * sin(dAnglmid));
        DoDrawArc( vX1, vY1
                  ,vXm, vYm
                  ,vXc, vYc
                 );
        DoDrawArc( vXm, vYm
                  ,vX2, vY2
                  ,vXc, vYc
                 );
        return;
    }

    //
    // Medium point
    //
    dAnglmid = (dAngl1 + dAngl2)/2.;
    vXm      = (wxCoord)(vXc + dRadius * cos(dAnglmid));
    vYm      = (wxCoord)(vYc + dRadius * sin(dAnglmid));

    //
    // Ellipse main axis (r,q), (p,s) with center at (0,0) */
    //
    vArcp.lR = 0;
    vArcp.lQ = 1;
    vArcp.lP = 1;
    vArcp.lS = 0;
    ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default

    vPtlPos.x = vX1; // Loads x-coordinate
    vPtlPos.y = vY1; // Loads y-coordinate
    ::GpiMove(m_hPS, &vPtlPos); // Sets current position
    vPtlArc[0].x = vXm;
    vPtlArc[0].y = vYm;
    vPtlArc[1].x = vX2;
    vPtlArc[1].y = vY2;
    ::GpiPointArc(m_hPS, vPtlArc); // Draws the arc
    CalcBoundingBox( (wxCoord)(vXc - dRadius)
                    ,(wxCoord)(vYc - dRadius)
                   );
    CalcBoundingBox( (wxCoord)(vXc + dRadius)
                    ,(wxCoord)(vYc + dRadius)
                   );
} // end of wxPMDCImpl::DoDrawArc

void wxPMDCImpl::DoDrawCheckMark(
  wxCoord                           vX1
, wxCoord                           vY1
, wxCoord                           vWidth
, wxCoord                           vHeight
)
{
    POINTL                          vPoint[2];

    vY1 = OS2Y(vY1,vHeight);

    vPoint[0].x = vX1;
    vPoint[0].y = vY1;
    vPoint[1].x = vX1 + vWidth;
    vPoint[1].y = vY1 + vHeight;

    ::GpiMove(m_hPS, &vPoint[0]);
    ::GpiBox( m_hPS       // handle to a presentation space
             ,DRO_OUTLINE // draw the box outline ? or ?
             ,&vPoint[1]  // address of the corner
             ,0L          // horizontal corner radius
             ,0L          // vertical corner radius
            );
    if(vWidth > 4 && vHeight > 4)
    {
        int                         nTmp;

        vPoint[0].x += 2; vPoint[0].y += 2;
        vPoint[1].x -= 2; vPoint[1].y -= 2;
        ::GpiMove(m_hPS, &vPoint[0]);
        ::GpiLine(m_hPS, &vPoint[1]);
        nTmp = vPoint[0].x;
        vPoint[0].x = vPoint[1].x;
        vPoint[1].x = nTmp;
        ::GpiMove(m_hPS, &vPoint[0]);
        ::GpiLine(m_hPS, &vPoint[1]);
    }
    CalcBoundingBox( vX1
                    ,vY1
                   );

    wxCoord                         vX2 = vX1 + vWidth;
    wxCoord                         vY2 = vY1 + vHeight;

    CalcBoundingBox( vX2
                    ,vY2
                   );
} // end of wxPMDCImpl::DoDrawCheckMark

void wxPMDCImpl::DoDrawPoint(
  wxCoord                           vX
, wxCoord                           vY
)
{
    POINTL                          vPoint;
    COLORREF                        vColor = 0x00ffffff;

    if (m_pen.IsOk())
    {
        vColor = m_pen.GetColour().GetPixel();
    }
    ::GpiSetColor(m_hPS, vColor);
    vPoint.x = vX;
    vPoint.y = OS2Y(vY,0);
    ::GpiSetPel(m_hPS, &vPoint);
    CalcBoundingBox( vX
                    ,vY
                   );
} // end of wxPMDCImpl::DoDrawPoint

void wxPMDCImpl::DoDrawPolygon( int n,
                          const wxPoint vPoints[],
                          wxCoord vXoffset,
                          wxCoord vYoffset,
                          wxPolygonFillMode nFillStyle )
{
    ULONG     ulCount = 1;    // Number of polygons.
    POLYGON   vPlgn;          // polygon.
    ULONG     flOptions = 0L; // Drawing options.

    //////////////////////////////////////////////////////////////////////////////
    // This contains fields of option bits... to draw boundary lines as well as
    // the area interior.
    //
    // Drawing boundary lines:
    //   POLYGON_NOBOUNDARY              Does not draw boundary lines.
    //   POLYGON_BOUNDARY                Draws boundary lines (the default).
    //
    // Construction of the area interior:
    //   POLYGON_ALTERNATE               Constructs interior in alternate mode
    //                                   (the default).
    //   POLYGON_WINDING                 Constructs interior in winding mode.
    //////////////////////////////////////////////////////////////////////////////

    ULONG     flModel = POLYGON_INCL; // Drawing model.

    //////////////////////////////////////////////////////////////////////////////
    // Drawing model.
    //   POLYGON_INCL  Fill is inclusive of bottom right (the default).
    //   POLYGON_EXCL  Fill is exclusive of bottom right.
    //       This is provided to aid migration from other graphics models.
    //////////////////////////////////////////////////////////////////////////////

    LONG      lHits = 0L; // Correlation/error indicator.
    int       i;
    int       nIsTRANSPARENT = 0;
    LONG      lBorderColor = 0L;
    LONG      lColor = 0L;

    lBorderColor = m_pen.GetColour().GetPixel();
    lColor       = m_brush.GetColour().GetPixel();
    if(m_brush.GetStyle() == wxTRANSPARENT)
        nIsTRANSPARENT = 1;

    vPlgn.ulPoints = n;
    vPlgn.aPointl = (POINTL*) calloc( n + 1
                                     ,sizeof(POINTL)
                                    ); // well, new will call malloc

    for(i = 0; i < n; i++)
    {
        vPlgn.aPointl[i].x = vPoints[i].x+vXoffset;
        vPlgn.aPointl[i].y = OS2Y(vPoints[i].y+vYoffset,0);
    }
    flOptions = POLYGON_BOUNDARY;
    if(nFillStyle == wxWINDING_RULE)
        flOptions |= POLYGON_WINDING;
    else
        flOptions |= POLYGON_ALTERNATE;

    ::GpiSetColor(m_hPS, lBorderColor);
    ::GpiMove(m_hPS, &vPlgn.aPointl[0]);
    lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
    free(vPlgn.aPointl);
} // end of wxPMDCImpl::DoDrawPolygon

void wxPMDCImpl::DoDrawLines(
  int                               n
, const wxPoint                           vPoints[]
, wxCoord                           vXoffset
, wxCoord                           vYoffset
)
{
    POINTL                          vPoint;

    if (vXoffset != 0L || vYoffset != 0L)
    {
        int                             i;

        vPoint.x = vPoints[0].x + vXoffset;
        vPoint.y = OS2Y(vPoints[0].y + vYoffset,0);
        ::GpiMove(m_hPS, &vPoint);

        LONG                            lBorderColor = m_pen.GetColour().GetPixel();

        ::GpiSetColor(m_hPS, lBorderColor);
        for(i = 1; i < n; i++)
        {
            vPoint.x = vPoints[i].x + vXoffset;
            vPoint.y = OS2Y(vPoints[i].y + vYoffset,0);
            ::GpiLine(m_hPS, &vPoint);
        }
    }
    else
    {
        int                         i;

        CalcBoundingBox( vPoints[0].x
                        ,vPoints[0].y
                       );
        vPoint.x = vPoints[0].x;
        vPoint.y = OS2Y(vPoints[0].y,0);
        ::GpiMove(m_hPS, &vPoint);

        for (i = 0; i < n; i++)
        {
            CalcBoundingBox( vPoints[i].x
                            ,vPoints[i].y
                           );
            vPoint.x = vPoints[i].x;
            vPoint.y = OS2Y(vPoints[i].y,0);
            ::GpiLine(m_hPS, &vPoint);
        }
    }
} // end of wxPMDCImpl::DoDrawLines

void wxPMDCImpl::DoDrawRectangle(
  wxCoord                           vX
, wxCoord                           vY
, wxCoord                           vWidth
, wxCoord                           vHeight
)
{
    POINTL                          vPoint[2];
    LONG                            lControl;
    LONG                            lColor;
    LONG                            lBorderColor;
    int                             nIsTRANSPARENT = 0;

    //
    // Might be a memory DC with no Paint rect.
    //
    if (!(m_vRclPaint.yTop == 0 &&
          m_vRclPaint.yBottom == 0 &&
          m_vRclPaint.xRight == 0 &&
          m_vRclPaint.xLeft == 0))
        vY = OS2Y(vY,vHeight);
    else
    {
        if (m_vSelectedBitmap.IsOk())
        {
            m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
            m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
            vY = OS2Y(vY,vHeight);
        }
    }

    wxCoord                         vX2 = vX + vWidth;
    wxCoord                         vY2 = vY + vHeight;

    vPoint[0].x = vX;
    vPoint[0].y = vY;
    vPoint[1].x = vX + vWidth - 1;
    vPoint[1].y = vY + vHeight - 1;
    ::GpiMove(m_hPS, &vPoint[0]);
    lColor       = m_brush.GetColour().GetPixel();
    lBorderColor = m_pen.GetColour().GetPixel();
    if (m_brush.GetStyle() == wxTRANSPARENT)
        nIsTRANSPARENT = 1;
    if(lColor == lBorderColor || nIsTRANSPARENT)
    {
        lControl = DRO_OUTLINEFILL; //DRO_FILL;
        if(m_brush.GetStyle() == wxTRANSPARENT)
            lControl = DRO_OUTLINE;

        ::GpiSetColor(m_hPS, lBorderColor);
        ::GpiBox( m_hPS       // handle to a presentation space
                 ,lControl   // draw the box outline ? or ?
                 ,&vPoint[1]  // address of the corner
                 ,0L          // horizontal corner radius
                 ,0L          // vertical corner radius
                );
    }
    else
    {
        lControl = DRO_OUTLINE;
        ::GpiSetColor( m_hPS
                      ,lBorderColor
                     );
        ::GpiBox( m_hPS
                 ,lControl
                 ,&vPoint[1]
                 ,0L
                 ,0L
                );
        lControl = DRO_FILL;
        ::GpiSetColor( m_hPS
                      ,lColor
                     );
        vPoint[0].x = vX + 1;
        vPoint[0].y = vY + 1;
        vPoint[1].x = vX + vWidth - 2;
        vPoint[1].y = vY + vHeight - 2;
        ::GpiMove(m_hPS, &vPoint[0]);
        ::GpiBox( m_hPS
                 ,lControl
                 ,&vPoint[1]
                 ,0L
                 ,0L
                );
    }
    CalcBoundingBox(vX, vY);
    CalcBoundingBox(vX2, vY2);
} // end of wxPMDCImpl::DoDrawRectangle

void wxPMDCImpl::DoDrawRoundedRectangle(
  wxCoord                           vX
, wxCoord                           vY
, wxCoord                           vWidth
, wxCoord                           vHeight
, double                            dRadius
)
{
    POINTL                          vPoint[2];
    LONG                            lControl;
    LONG                            lColor;
    LONG                            lBorderColor;
    int                             nIsTRANSPARENT = 0;

    //
    // Might be a memory DC with no Paint rect.
    //
    if (!(m_vRclPaint.yTop == 0 &&
          m_vRclPaint.yBottom == 0 &&
          m_vRclPaint.xRight == 0 &&
          m_vRclPaint.xLeft == 0))
        vY = OS2Y(vY,vHeight);
    else
    {
        if (m_vSelectedBitmap.IsOk())
        {
            m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
            m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
            vY = OS2Y(vY,vHeight);
        }
    }

    wxCoord                         vX2 = (vX + vWidth);
    wxCoord                         vY2 = (vY + vHeight);

    vPoint[0].x = vX;
    vPoint[0].y = vY;
    vPoint[1].x = vX + vWidth - 1;
    vPoint[1].y = vY + vHeight - 1;
    ::GpiMove(m_hPS, &vPoint[0]);

    lColor       = m_brush.GetColour().GetPixel();
    lBorderColor = m_pen.GetColour().GetPixel();
    lControl = DRO_OUTLINEFILL; //DRO_FILL;
    if (m_brush.GetStyle() == wxTRANSPARENT)
        nIsTRANSPARENT = 1;
    if(lColor == lBorderColor || nIsTRANSPARENT)
    {
        lControl = DRO_OUTLINEFILL; //DRO_FILL;
        if(m_brush.GetStyle() == wxTRANSPARENT)
            lControl = DRO_OUTLINE;

        ::GpiSetColor(m_hPS, lColor);
        ::GpiBox( m_hPS         // handle to a presentation space
                 ,lControl      // draw the box outline ? or ?
                 ,&vPoint[1]    // address of the corner
                 ,(LONG)dRadius // horizontal corner radius
                 ,(LONG)dRadius // vertical corner radius
                );
    }
    else
    {
        lControl = DRO_OUTLINE;
        ::GpiSetColor( m_hPS
                      ,lBorderColor
                     );
        ::GpiBox( m_hPS
                 ,lControl
                 ,&vPoint[1]
                 ,(LONG)dRadius
                 ,(LONG)dRadius
                );
        lControl = DRO_FILL;
        ::GpiSetColor( m_hPS
                      ,lColor
                     );
        vPoint[0].x = vX + 1;
        vPoint[0].y = vY + 1;
        vPoint[1].x = vX + vWidth - 2;
        vPoint[1].y = vY + vHeight - 2;
        ::GpiMove(m_hPS, &vPoint[0]);
        ::GpiBox( m_hPS
                 ,lControl
                 ,&vPoint[1]
                 ,(LONG)dRadius
                 ,(LONG)dRadius
                );
    }

    CalcBoundingBox(vX, vY);
    CalcBoundingBox(vX2, vY2);
} // end of wxPMDCImpl::DoDrawRoundedRectangle

// Draw Ellipse within box (x,y) - (x+width, y+height)
void wxPMDCImpl::DoDrawEllipse(
  wxCoord                           vX
, wxCoord                           vY
, wxCoord                           vWidth
, wxCoord                           vHeight
)
{
    POINTL                          vPtlPos; // Structure for current position
    FIXED                           vFxMult; // Multiplier for ellipse
    ARCPARAMS                       vArcp;   // Structure for arc parameters

    vY = OS2Y(vY,vHeight);

    vArcp.lR = 0;
    vArcp.lQ = vHeight/2;
    vArcp.lP = vWidth/2;
    vArcp.lS = 0;
    ::GpiSetArcParams( m_hPS
                      ,&vArcp
                     ); // Sets parameters to default
    vPtlPos.x = vX + vWidth/2;  // Loads x-coordinate
    vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
    ::GpiMove( m_hPS
              ,&vPtlPos
             ); // Sets current position
    vFxMult = MAKEFIXED(1, 0);             /* Sets multiplier            */

    //
    // DRO_FILL, DRO_OTLINEFILL - where to get
    //
    ::GpiFullArc( m_hPS
                 ,DRO_OUTLINE
                 ,vFxMult
                ); // Draws full arc with center at current position

    wxCoord                         vX2 = (vX + vWidth);
    wxCoord                         vY2 = (vY + vHeight);

    CalcBoundingBox(vX, vY);
    CalcBoundingBox(vX2, vY2);
} // end of wxPMDCImpl::DoDrawEllipse

void wxPMDCImpl::DoDrawEllipticArc(
  wxCoord                           vX
, wxCoord                           vY
, wxCoord                           vWidth
, wxCoord                           vHeight
, double                            dSa
, double                            dEa
)
{
    POINTL                          vPtlPos; // Structure for current position
    FIXED                           vFxMult; // Multiplier for ellipse
    ARCPARAMS                       vArcp;   // Structure for arc parameters
    FIXED                           vFSa;
    FIXED                           vFSweepa; // Start angle, sweep angle
    double                          dIntPart;
    double                          dFractPart;

    vY = OS2Y(vY,vHeight);

    dFractPart = modf(dSa,&dIntPart);
    vFSa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
    dFractPart = modf(dEa - dSa, &dIntPart);
    vFSweepa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );

    //
    // Ellipse main axis (r,q), (p,s) with center at (0,0)
    //
    vArcp.lR = 0;
    vArcp.lQ = vHeight/2;
    vArcp.lP = vWidth/2;
    vArcp.lS = 0;
    ::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
    vPtlPos.x = (wxCoord)(vX + vWidth/2  * (1. + cos(DegToRad(dSa)))); // Loads x-coordinate
    vPtlPos.y = (wxCoord)(vY + vHeight/2 * (1. + sin(DegToRad(dSa)))); // Loads y-coordinate
    ::GpiMove(m_hPS, &vPtlPos); // Sets current position

    //
    // May be not to the center ?
    //
    vPtlPos.x = vX + vWidth/2 ; // Loads x-coordinate
    vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
    vFxMult = MAKEFIXED(1, 0);  // Sets multiplier

    //
    // DRO_FILL, DRO_OTLINEFILL - where to get
    //
    ::GpiPartialArc( m_hPS
                    ,&vPtlPos
                    ,vFxMult
                    ,vFSa
                    ,vFSweepa
                   );
    wxCoord                         vX2 = (vX + vWidth);
    wxCoord                         vY2 = (vY + vHeight);

    CalcBoundingBox(vX, vY);
    CalcBoundingBox(vX2, vY2);
} // end of wxPMDCImpl::DoDrawEllipticArc

void wxPMDCImpl::DoDrawIcon(
  const wxIcon&                     rIcon
, wxCoord                           vX
, wxCoord                           vY
)
{
    //
    // Need to copy back into a bitmap.  ::WinDrawPointer uses device coords
    // and I don't feel like figuring those out for scrollable windows so
    // just convert to a bitmap then let the DoDrawBitmap routine display it
    //
    if (rIcon.IsXpm())
    {
        DoDrawBitmap(rIcon.GetXpmSrc(), vX, vY, true);
    }
    else
    {
        wxBitmap                        vBitmap(rIcon);

        DoDrawBitmap(vBitmap, vX, vY, false);
    }
    CalcBoundingBox(vX, vY);
    CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
} // end of wxPMDCImpl::DoDrawIcon

void wxPMDCImpl::DoDrawBitmap(
  const wxBitmap&                   rBmp
, wxCoord                           vX
, wxCoord                           vY
, bool                              bUseMask
)
{
#if wxUSE_PRINTING_ARCHITECTURE
    if (!IsKindOf(CLASSINFO(wxPrinterDC)))
#endif
    {
        HBITMAP                         hBitmap =  (HBITMAP)rBmp.GetHBITMAP();
        HBITMAP                         hBitmapOld = NULLHANDLE;
        POINTL                          vPoint[4];

        vY = OS2Y(vY,rBmp.GetHeight());

        vPoint[0].x = vX;
        vPoint[0].y = vY + rBmp.GetHeight();
        vPoint[1].x = vX + rBmp.GetWidth();
        vPoint[1].y = vY;
        vPoint[2].x = 0;
        vPoint[2].y = 0;
        vPoint[3].x = rBmp.GetWidth();
        vPoint[3].y = rBmp.GetHeight();
        if (bUseMask)
        {
            wxMask*                     pMask = rBmp.GetMask();

            if (pMask)
            {
                //
                // Need to imitate ::MaskBlt in windows.
                // 1) Extract the bits from from the bitmap.
                // 2) Extract the bits from the mask
                // 3) Using the mask bits do the following:
                //   A) If the mask byte is 00 leave the bitmap byte alone
                //   B) If the mask byte is FF copy the screen color into
                //      bitmap byte
                // 4) Create a new bitmap and set its bits to the above result
                // 5) Blit this to the screen PS
                //
                HBITMAP                 hMask = (HBITMAP)pMask->GetMaskBitmap();
                HBITMAP                 hOldMask   = NULLHANDLE;
                HBITMAP                 hOldBitmap = NULLHANDLE;
                HBITMAP                 hNewBitmap = NULLHANDLE;
                unsigned char*          pucBits;     // buffer that will contain the bitmap data
                unsigned char*          pucBitsMask; // buffer that will contain the mask data
                unsigned char*          pucData;     // pointer to use to traverse bitmap data
                unsigned char*          pucDataMask; // pointer to use to traverse mask data
                LONG                    lHits;
                ERRORID                 vError;
                wxString                sError;

                //
                // The usual Memory context creation stuff
                //
                DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
                SIZEL                           vSize = {0, 0};
                HDC                             hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
                HPS                             hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);

                //
                // The usual bitmap header stuff
                //
                BITMAPINFOHEADER2               vHeader;
                BITMAPINFO2                     vInfo;

                memset(&vHeader, '\0', 16);
                vHeader.cbFix           = 16;

                memset(&vInfo, '\0', 16);
                vInfo.cbFix           = 16;
                vInfo.cx              = (ULONG)rBmp.GetWidth();
                vInfo.cy              = (ULONG)rBmp.GetHeight();
                vInfo.cPlanes         = 1;
                vInfo.cBitCount       = 24; // Set to desired count going in

                //
                // Create the buffers for data....all wxBitmaps are 24 bit internally
                //
                int                     nBytesPerLine = rBmp.GetWidth() * 3;
                int                     nSizeDWORD    = sizeof(DWORD);
                int                     nLineBoundary = nBytesPerLine % nSizeDWORD;
                int                     nPadding = 0;
                int                     i;
                int                     j;
                LONG                    lScans = 0L;
                LONG                    lColor = 0L;

                //
                // Need to get a background color for mask blitting
                //
                if (IsKindOf(CLASSINFO(wxWindowDCImpl)))
                {
                    wxWindowDCImpl*  pWindowDC = wxDynamicCast(this, wxWindowDCImpl);

                    lColor = pWindowDC->m_pCanvas->GetBackgroundColour().GetPixel();
                }
                else if (GetBrush().IsOk())
                    lColor = GetBrush().GetColour().GetPixel();
                else
                    lColor = m_textBackgroundColour.GetPixel();

                //
                // Bitmap must be in a double-word aligned address so we may
                // have some padding to worry about
                //
                if (nLineBoundary > 0)
                {
                    nPadding     = nSizeDWORD - nLineBoundary;
                    nBytesPerLine += nPadding;
                }
                pucBits = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
                pucBitsMask = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
                memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));
                memset(pucBitsMask, '\0', (nBytesPerLine * rBmp.GetHeight()));

                //
                // Extract the bitmap and mask data
                //
                if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                }
                ::GpiQueryBitmapInfoHeader(hBitmap, &vHeader);
                vInfo.cBitCount = 24;
                if ((lScans = ::GpiQueryBitmapBits( hPS
                                                   ,0L
                                                   ,(LONG)rBmp.GetHeight()
                                                   ,(PBYTE)pucBits
                                                   ,&vInfo
                                                  )) == GPI_ALTERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                }
                if ((hOldMask = ::GpiSetBitmap(hPS, hMask)) == HBM_ERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                }
                ::GpiQueryBitmapInfoHeader(hMask, &vHeader);
                vInfo.cBitCount = 24;
                if ((lScans = ::GpiQueryBitmapBits( hPS
                                                   ,0L
                                                   ,(LONG)rBmp.GetHeight()
                                                   ,(PBYTE)pucBitsMask
                                                   ,&vInfo
                                                  )) == GPI_ALTERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                }
                if (( hMask = ::GpiSetBitmap(hPS, hOldMask)) == HBM_ERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                }

                //
                // Now set the bytes(bits) according to the mask values
                // 3 bytes per pel...must handle one at a time
                //
                pucData     = pucBits;
                pucDataMask = pucBitsMask;

                //
                // 16 bit kludge really only kinda works.  The mask gets applied
                // where needed but the original bitmap bits are dorked sometimes
                //
                bool                    bpp16 = (wxDisplayDepth() == 16);

                for (i = 0; i < rBmp.GetHeight(); i++)
                {
                    for (j = 0; j < rBmp.GetWidth(); j++)
                    {
                        // Byte 1
                        if (bpp16 && *pucDataMask == 0xF8) // 16 bit display gobblygook
                            pucData++;
                        else if (*pucDataMask == 0xFF) // leave bitmap byte alone
                            pucData++;
                        else
                        {
                            *pucData = ((unsigned char)(lColor >> 16));
                            pucData++;
                        }
                        // Byte 2
                        if (bpp16 && *(pucDataMask + 1) == 0xFC) // 16 bit display gobblygook
                            pucData++;
                        else if (*(pucDataMask + 1) == 0xFF) // leave bitmap byte alone
                            pucData++;
                        else
                        {
                            *pucData = ((unsigned char)(lColor >> 8));
                            pucData++;
                        }

                        // Byte 3
                        if (bpp16 && *(pucDataMask + 2) == 0xF8) // 16 bit display gobblygook
                            pucData++;
                        else if (*(pucDataMask + 2) == 0xFF) // leave bitmap byte alone
                            pucData++;
                        else
                        {
                            *pucData = ((unsigned char)lColor);
                            pucData++;
                        }
                        pucDataMask += 3;
                    }
                    for (j = 0; j < nPadding; j++)
                    {
                        pucData++;
                        pucDataMask++;
                    }
                }
                //
                // Create a new bitmap
                //
                vHeader.cx              = (ULONG)rBmp.GetWidth();
                vHeader.cy              = (ULONG)rBmp.GetHeight();
                vHeader.cPlanes         = 1L;
                vHeader.cBitCount       = 24;
                if ((hNewBitmap = ::GpiCreateBitmap( hPS
                                                    ,&vHeader
                                                    ,CBM_INIT
                                                    ,(PBYTE)pucBits
                                                    ,&vInfo
                                                   )) == GPI_ERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                }

                //
                // Now blit it to the screen PS
                //
                if ((lHits = ::GpiWCBitBlt( (HPS)GetHPS()
                                           ,hNewBitmap
                                           ,4
                                           ,vPoint
                                           ,ROP_SRCCOPY
                                           ,BBO_IGNORE
                                          )) == GPI_ERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                }

                //
                // Clean up
                //
                free(pucBits);
                free(pucBitsMask);
                ::GpiSetBitmap(hPS, NULLHANDLE);
                ::GpiDeleteBitmap(hNewBitmap);
                ::GpiDestroyPS(hPS);
                ::DevCloseDC(hDC);
            }
        }
        else
        {
            ULONG                       lOldForeGround = ::GpiQueryColor((HPS)GetHPS());
            ULONG                       lOldBackGround = ::GpiQueryBackColor((HPS)GetHPS());

            if (m_textForegroundColour.IsOk())
            {
                ::GpiSetColor( (HPS)GetHPS()
                               ,m_textForegroundColour.GetPixel()
                              );
            }
            if (m_textBackgroundColour.IsOk())
            {
                ::GpiSetBackColor( (HPS)GetHPS()
                                  ,m_textBackgroundColour.GetPixel()
                                 );
            }
            //
            // Need to alter bits in a mono bitmap to match the new
            // background-foreground if it is different.
            //
            if (rBmp.IsMono() &&
               ((m_textForegroundColour.GetPixel() != lOldForeGround) ||
                (m_textBackgroundColour.GetPixel() != lOldBackGround)))
            {
                DEVOPENSTRUC        vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
                SIZEL               vSize = {0, 0};
                HDC                 hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
                HPS                 hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);

                int                 nBytesPerLine = rBmp.GetWidth() * 3;
                int                 i, j;
                LONG                lForeGround = m_textForegroundColour.GetPixel();
                LONG                lBackGround = m_textBackgroundColour.GetPixel();
                LONG                lScans;
                HBITMAP             hOldBitmap = NULLHANDLE;
                BITMAPINFO2         vInfo;
                ERRORID             vError;
                wxString            sError;


                memset(&vInfo, '\0', 16);
                vInfo.cbFix           = 16;
                vInfo.cx              = (ULONG)rBmp.GetWidth();
                vInfo.cy              = (ULONG)rBmp.GetHeight();
                vInfo.cPlanes         = 1;
                vInfo.cBitCount       = 24;

                unsigned char*          pucBits;     // buffer that will contain the bitmap data
                unsigned char*          pucData;     // pointer to use to traverse bitmap data

                pucBits = new unsigned char[nBytesPerLine * rBmp.GetHeight()];
                memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));

                if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                    delete [] pucBits;
                    return;
                }
                if ((lScans = ::GpiQueryBitmapBits( hPS
                                                   ,0L
                                                   ,(LONG)rBmp.GetHeight()
                                                   ,(PBYTE)pucBits
                                                   ,&vInfo
                                                  )) == GPI_ALTERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                    delete [] pucBits;
                    return;
                }
                unsigned char           cOldRedFore   = (unsigned char)(lOldForeGround >> 16);
                unsigned char           cOldGreenFore = (unsigned char)(lOldForeGround >> 8);
                unsigned char           cOldBlueFore  = (unsigned char)lOldForeGround;

                unsigned char           cRedFore   = (unsigned char)(lForeGround >> 16);
                unsigned char           cGreenFore = (unsigned char)(lForeGround >> 8);
                unsigned char           cBlueFore  = (unsigned char)lForeGround;

                unsigned char           cRedBack   = (unsigned char)(lBackGround >> 16);
                unsigned char           cGreenBack = (unsigned char)(lBackGround >> 8);
                unsigned char           cBlueBack  = (unsigned char)lBackGround;

                pucData = pucBits;
                for (i = 0; i < rBmp.GetHeight(); i++)
                {
                    for (j = 0; j < rBmp.GetWidth(); j++)
                    {
                        unsigned char    cBmpRed   = *pucData;
                        unsigned char    cBmpGreen = *(pucData + 1);
                        unsigned char    cBmpBlue  = *(pucData + 2);

                        if ((cBmpRed == cOldRedFore) &&
                            (cBmpGreen == cOldGreenFore) &&
                            (cBmpBlue == cOldBlueFore))
                        {
                            *pucData = cBlueFore;
                            pucData++;
                            *pucData = cGreenFore;
                            pucData++;
                            *pucData = cRedFore;
                            pucData++;
                        }
                        else
                        {
                            *pucData = cBlueBack;
                            pucData++;
                            *pucData = cGreenBack;
                            pucData++;
                            *pucData = cRedBack;
                            pucData++;
                        }
                    }
                }
                if ((lScans = ::GpiSetBitmapBits( hPS
                                                 ,0L
                                                 ,(LONG)rBmp.GetHeight()
                                                 ,(PBYTE)pucBits
                                                 ,&vInfo
                                                )) == GPI_ALTERROR)
                {
                    vError = ::WinGetLastError(vHabmain);
                    sError = wxPMErrorToStr(vError);
                    return;
                }
                delete [] pucBits;
                ::GpiSetBitmap(hPS, NULLHANDLE);
                ::GpiDestroyPS(hPS);
                ::DevCloseDC(hDC);
            }
            ::GpiWCBitBlt( (HPS)GetHPS()
                          ,hBitmap
                          ,4
                          ,vPoint
                          ,ROP_SRCCOPY
                          ,BBO_IGNORE
                         );
            ::GpiSetBitmap((HPS)GetHPS(), hBitmapOld);
            ::GpiSetColor((HPS)GetHPS(), lOldForeGround);
            ::GpiSetBackColor((HPS)GetHPS(), lOldBackGround);
        }
    }
} // end of wxPMDCImpl::DoDrawBitmap

void wxPMDCImpl::DoDrawText(
  const wxString&                   rsText
, wxCoord                           vX
, wxCoord                           vY
)
{
    wxCoord                         vWidth;
    wxCoord                         vHeight;

    DrawAnyText( rsText
                ,vX
                ,vY
               );

    CalcBoundingBox(vX, vY);
    GetOwner()->GetTextExtent(rsText, &vWidth, &vHeight);
    CalcBoundingBox((vX + vWidth), (vY + vHeight));
} // end of wxPMDCImpl::DoDrawText

void wxPMDCImpl::DrawAnyText( const wxString& rsText,
                        wxCoord vX,
                        wxCoord vY )
{
    int                             nOldBackground = 0;
    POINTL                          vPtlStart;
    LONG                            lHits;
    wxCoord                         vTextX = 0;
    wxCoord                         vTextY = 0;

    //
    // prepare for drawing the text
    //

    //
    // Set text color attributes
    //
    if (m_textForegroundColour.IsOk())
    {
        SetTextColor( m_hPS
                     ,(int)m_textForegroundColour.GetPixel()
                    );
    }

    if (m_textBackgroundColour.IsOk())
    {
        nOldBackground = SetTextBkColor( m_hPS
                                        ,(int)m_textBackgroundColour.GetPixel()
                                       );
    }
    SetBkMode( m_hPS
              ,m_backgroundMode
             );
    GetOwner()->GetTextExtent( rsText
                              ,&vTextX
                              ,&vTextY
                             );
    vPtlStart.x = vX;
    if (!(m_vRclPaint.yTop == 0 &&
          m_vRclPaint.yBottom == 0 &&
          m_vRclPaint.xRight == 0 &&
          m_vRclPaint.xLeft == 0))
    {
        vPtlStart.y = OS2Y(vY,vTextY);
    }
    else
    {
        if (m_vSelectedBitmap.IsOk())
        {
            m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
            m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
            vPtlStart.y = OS2Y(vY,vTextY);
        }
        else
            vPtlStart.y = vY;
    }

    ::GpiMove(m_hPS, &vPtlStart);
    lHits = ::GpiCharString( m_hPS
                            ,rsText.length()
                            ,rsText.char_str()
                           );
    if (lHits != GPI_OK)
    {
        wxLogLastError(wxT("TextOut"));
    }

    //
    // Restore the old parameters (text foreground colour may be left because
    // it never is set to anything else, but background should remain
    // transparent even if we just drew an opaque string)
    //
    if (m_textBackgroundColour.IsOk())
            SetTextBkColor( m_hPS
                           ,nOldBackground
                          );
    SetBkMode( m_hPS
              ,wxTRANSPARENT
             );
}

void wxPMDCImpl::DoDrawRotatedText(
  const wxString&                   rsText
, wxCoord                           vX
, wxCoord                           vY
, double                            dAngle
)
{
    if (dAngle == 0.0)
    {
        DoDrawText( rsText
                   ,vX
                   ,vY
                  );
    }

   // TODO:
   /*
    if ( angle == 0.0 )
    {
        DoDrawText(text, x, y);
    }
    else
    {
        LOGFONT lf;
        wxFillLogFont(&lf, &m_font);

        // GDI wants the angle in tenth of degree
        long angle10 = (long)(angle * 10);
        lf.lfEscapement = angle10;
        lf. lfOrientation = angle10;

        HFONT hfont = ::CreateFontIndirect(&lf);
        if ( !hfont )
        {
            wxLogLastError("CreateFont");
        }
        else
        {
            HFONT hfontOld = ::SelectObject(GetHdc(), hfont);

            DrawAnyText(text, x, y);

            (void)::SelectObject(GetHdc(), hfontOld);
        }

        // call the bounding box by adding all four vertices of the rectangle
        // containing the text to it (simpler and probably not slower than
        // determining which of them is really topmost/leftmost/...)
        wxCoord w, h;
        GetTextExtent(text, &w, &h);

        double rad = DegToRad(angle);

        // "upper left" and "upper right"
        CalcBoundingBox(x, y);
        CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
        CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));

        // "bottom left" and "bottom right"
        x += (wxCoord)(h*sin(rad));
        y += (wxCoord)(h*cos(rad));
        CalcBoundingBox(x, y);
        CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
    }
*/
}

// ---------------------------------------------------------------------------
// set GDI objects
// ---------------------------------------------------------------------------

void wxPMDCImpl::DoSelectPalette( bool WXUNUSED(bRealize) )
{
    //
    // Set the old object temporarily, in case the assignment deletes an object
    // that's not yet selected out.
    //
    if (m_hOldPalette)
    {
        m_hOldPalette = 0;
    }

    if (m_palette.IsOk())
    {
        HPALETTE                    hOldPal;

        hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
        if (!m_hOldPalette)
            m_hOldPalette = (WXHPALETTE)hOldPal;
    }
} // end of wxPMDCImpl::DoSelectPalette

void wxPMDCImpl::InitializePalette()
{
    if (wxDisplayDepth() <= 8 )
    {
        //
        // Look for any window or parent that has a custom palette. If any has
        // one then we need to use it in drawing operations
        //
        wxWindow*                   pWin = m_pCanvas->GetAncestorWithCustomPalette();

        m_hasCustomPalette = pWin && pWin->HasCustomPalette();
        if (m_hasCustomPalette)
        {
            m_palette = pWin->GetPalette();

            //
            // turn on PM translation for this palette
            //
            DoSelectPalette();
        }
    }
} // end of wxPMDCImpl::InitializePalette

void wxPMDCImpl::SetPalette(
  const wxPalette&                  rPalette
)
{
    if (m_hOldFont)
    {
        m_hOldFont = 0;
    }
    m_palette = rPalette;
    if (!rPalette.IsOk())
    {
        if (m_hOldFont)
        {
            m_hOldFont = 0;
        }
    }
    HPALETTE                    hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
    if (!m_hOldPalette)
        m_hOldPalette = (WXHPALETTE)hOldPal;
} // end of wxPMDCImpl::SetPalette

void wxPMDCImpl::SetFont(
  const wxFont&                     rFont
)
{
    //
    // Set the old object temporarily, in case the assignment deletes an object
    // that's not yet selected out.
    //
    if (m_hOldFont)
    {
        m_hOldFont = 0;
    }
    m_font = rFont;
    if (!rFont.IsOk())
    {
        m_hOldFont = 0;
    }

    m_font.SetPS(m_hPS); // this will realize the font

    if (m_font.IsOk())
    {
        HFONT                       hFont = m_font.GetResourceHandle();
        if (hFont == (HFONT) NULL)
        {
            wxLogDebug(wxT("::SelectObject failed in wxPMDCImpl::SetFont."));
        }
        if (!m_hOldFont)
            m_hOldFont = (WXHFONT) hFont;
    }
} // end of wxPMDCImpl::SetFont

void wxPMDCImpl::SetPen(
  const wxPen&                      rPen
)
{
    if (m_pen == rPen)
        return;
    m_pen = rPen;
    if (!m_pen.IsOk())
        return;

    if (m_hOldPen)
        m_hOldPen = 0L;
    m_pen = rPen;

    if (!m_pen.IsOk())
    {
        if (m_hOldPen)
        {
            m_pen.SetPS((HPS)m_hOldPen);
        }
        m_hOldPen = 0L;
    }

    if (m_pen.IsOk())
    {
        if (m_pen.GetResourceHandle())
        {
            m_pen.SetPS(m_hPS);
            if (!m_hOldPen)
                m_hOldPen = m_pen.GetPS();
        }
        ::GpiSetColor(m_hPS, m_pen.GetColour().GetPixel());
    }
}

void wxPMDCImpl::SetBrush(
  const wxBrush&                    rBrush
)
{
    if (m_hOldBrush)
        m_hOldBrush = 0L;
    m_brush = rBrush;
    if (!m_brush.IsOk())
    if (m_brush == rBrush)
        return;
    if (!m_brush.IsOk())
        if (m_hOldBrush)
            m_hOldBrush = 0L;

    if (!m_brush.IsOk())
    {
        if (m_hOldBrush)
        {
            m_brush.SetPS((HPS)m_hOldBrush);
        }
        m_hOldBrush = 0L;
    }

    if (m_brush.IsOk())
    {
        if (m_brush.GetResourceHandle())
        {
            m_brush.SetPS(m_hPS);
            if (!m_hOldBrush)
                m_hOldBrush = (WXHWND)m_brush.GetPS();
        }
    }
} // end of wxPMDCImpl::SetBrush

void wxPMDCImpl::SetBackground(const wxBrush& rBrush)
{
    m_backgroundBrush = rBrush;

    if (m_backgroundBrush.IsOk())
    {
        (void)::GpiSetBackColor((HPS)m_hPS, m_backgroundBrush.GetColour().GetPixel());
    }
} // end of wxPMDCImpl::SetBackground

void wxPMDCImpl::SetBackgroundMode(int nMode)
{
    m_backgroundMode = nMode;
} // end of wxPMDCImpl::SetBackgroundMode

void wxPMDCImpl::SetLogicalFunction(wxRasterOperationMode nFunction)
{
    m_logicalFunction = nFunction;
    SetRop((WXHDC)m_hDC);
} // wxPMDCImpl::SetLogicalFunction

void wxPMDCImpl::SetRop(WXHDC hDC)
{
    if (!hDC || m_logicalFunction < 0)
        return;

    LONG lCRop;
    switch (m_logicalFunction)
    {
        case wxXOR:
            lCRop = FM_XOR;
            break;

        case wxINVERT:
            lCRop = FM_INVERT;
            break;

        case wxOR_REVERSE:
            lCRop = FM_MERGESRCNOT;
            break;

        case wxAND_REVERSE:
            lCRop = FM_NOTMASKSRC;
            break;

        case wxCLEAR:
            lCRop = FM_ONE;
            break;

        case wxSET:
            lCRop = FM_ZERO;
            break;

        case wxSRC_INVERT:
            lCRop = FM_MERGENOTSRC;
            break;

        case wxOR_INVERT:
            lCRop = FM_MERGESRCNOT;
            break;

        case wxAND:
            lCRop = FM_AND;
            break;

        case wxOR:
            lCRop = FM_OR;
            break;

        case wxAND_INVERT:
            lCRop = FM_SUBTRACT;
            break;

        case wxEQUIV:
        case wxNAND:
        case wxCOPY:
        default:
            lCRop = FM_OVERPAINT;
            break;
    }
    ::GpiSetMix((HPS)hDC, lCRop);
} // end of wxPMDCImpl::SetRop

bool wxPMDCImpl::StartDoc( const wxString& WXUNUSED(rsMessage) )
{
    // We might be previewing, so return true to let it continue.
    return true;
} // end of wxPMDCImpl::StartDoc

void wxPMDCImpl::EndDoc()
{
} // end of wxPMDCImpl::EndDoc

void wxPMDCImpl::StartPage()
{
} // end of wxPMDCImpl::StartPage

void wxPMDCImpl::EndPage()
{
} // end of wxPMDCImpl::EndPage

// ---------------------------------------------------------------------------
// text metrics
// ---------------------------------------------------------------------------

wxCoord wxPMDCImpl::GetCharHeight() const
{
    FONTMETRICS                     vFM; // metrics structure

    ::GpiQueryFontMetrics( m_hPS
                          ,sizeof(FONTMETRICS)
                          ,&vFM
                         );
    return YDEV2LOGREL(vFM.lXHeight);
}

wxCoord wxPMDCImpl::GetCharWidth() const
{
    FONTMETRICS                     vFM; // metrics structure

    ::GpiQueryFontMetrics( m_hPS
                          ,sizeof(FONTMETRICS)
                          ,&vFM
                         );
    return XDEV2LOGREL(vFM.lAveCharWidth);
}

void wxPMDCImpl::DoGetTextExtent(
  const wxString&                   rsString
, wxCoord*                          pvX
, wxCoord*                          pvY
, wxCoord*                          pvDescent
, wxCoord*                          pvExternalLeading
, const wxFont*                     pTheFont
) const
{
    POINTL                          avPoint[TXTBOX_COUNT];
    POINTL                          vPtMin;
    POINTL                          vPtMax;
    int                             i;
    int                             l;
    FONTMETRICS                     vFM; // metrics structure
    BOOL                            bRc;
    ERRORID                         vErrorCode; // last error id code
    wxFont*                         pFontToUse = (wxFont*)pTheFont;

    wxChar                          zMsg[128]; // DEBUG
    wxString                        sError;

    if (!pFontToUse)
        pFontToUse = (wxFont*)&m_font;
    l = rsString.length();

    //
    // In world coordinates.
    //
    if (!m_hPS)
    {
    (void)wxMessageBox( wxT("wxWidgets core library")
                ,"Using uninitialized DC for measuring text!\n"
                ,wxICON_INFORMATION
                );
    }

    bRc = ::GpiQueryTextBox( m_hPS
                            ,l
                            ,rsString.char_str()
                            ,TXTBOX_COUNT // return maximum information
                            ,avPoint      // array of coordinates points
                           );
    if(!bRc)
    {
       vErrorCode = ::WinGetLastError(wxGetInstance());
       sError = wxPMErrorToStr(vErrorCode);
       // DEBUG
       wxSprintf(zMsg, wxT("GpiQueryTextBox for %s: failed with Error: %lx - %s"), rsString.c_str(), vErrorCode, sError.c_str());
       (void)wxMessageBox( wxT("wxWidgets core library")
                          ,zMsg
                          ,wxICON_INFORMATION
                         );
    }

    vPtMin.x = avPoint[0].x;
    vPtMax.x = avPoint[0].x;
    vPtMin.y = avPoint[0].y;
    vPtMax.y = avPoint[0].y;
    for (i = 1; i < 4; i++)
    {
        if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
        if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
        if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
        if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
    }
    ::GpiQueryFontMetrics( m_hPS
                          ,sizeof(FONTMETRICS)
                          ,&vFM
                         );

    if (pvX)
        *pvX = (wxCoord)(vPtMax.x - vPtMin.x + 1);
    if (pvY)
        *pvY = (wxCoord)(vPtMax.y - vPtMin.y + 1);
    if (pvDescent)
        *pvDescent = vFM.lMaxDescender;
    if (pvExternalLeading)
        *pvExternalLeading = vFM.lExternalLeading;
}

void wxPMDCImpl::SetMapMode(
  wxMappingMode                     nMode
)
{
    int                             nPixelWidth = 0;
    int                             nPixelHeight = 0;
    int                             nMmWidth = 1;
    int                             nMmHeight = 1;
    LONG                            lArray[CAPS_VERTICAL_RESOLUTION+1];

    m_mappingMode = nMode;

    if(::DevQueryCaps( m_hDC
                      ,CAPS_FAMILY                  // id of first item
                      ,CAPS_VERTICAL_RESOLUTION+1   // number of items wanted
                      ,lArray
                     ))
    {
        LONG                        lHorzRes;
        LONG                        lVertRes;

        nPixelWidth    = lArray[CAPS_WIDTH];
        nPixelHeight   = lArray[CAPS_HEIGHT];
        lHorzRes  = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
        lVertRes  = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
        nMmWidth  = (lHorzRes/1000) * nPixelWidth;
        nMmHeight = (lVertRes/1000) * nPixelHeight;
    }
    if ((nPixelWidth == 0) || (nPixelHeight == 0) || (nMmWidth == 0) || (nMmHeight == 0))
    {
        return;
    }

    double dMm2pixelsX = nPixelWidth/(double)nMmWidth;
    double dMm2pixelsY = nPixelHeight/(double)nMmHeight;

    switch (nMode)
    {
        case wxMM_TWIPS:
            m_logicalScaleX = (twips2mm * dMm2pixelsX);
            m_logicalScaleY = (twips2mm * dMm2pixelsY);
            break;

        case wxMM_POINTS:
            m_logicalScaleX = (pt2mm * dMm2pixelsX);
            m_logicalScaleY = (pt2mm * dMm2pixelsY);
            break;

        case wxMM_METRIC:
            m_logicalScaleX = dMm2pixelsX;
            m_logicalScaleY = dMm2pixelsY;
            break;

        case wxMM_LOMETRIC:
            m_logicalScaleX = (dMm2pixelsX/10.0);
            m_logicalScaleY = (dMm2pixelsY/10.0);
            break;

        case wxMM_TEXT:
        default:
            m_logicalScaleX = 1.0;
            m_logicalScaleY = 1.0;
            break;
    }

    SIZEL                           vSize;
    ULONG                           ulOptions;

    ulOptions = ::GpiQueryPS(m_hPS, &vSize);
    if (!ulOptions & PU_ARBITRARY)
    {
        ulOptions = PU_ARBITRARY | GPIF_DEFAULT;
        ::GpiSetPS(m_hPS, &vSize, ulOptions);
    }
    ComputeScaleAndOrigin();

}; // end of wxPMDCImpl::SetMapMode

void wxPMDCImpl::SetUserScale( double dX,
                         double dY )
{
    m_userScaleX = dX;
    m_userScaleY = dY;

    SetMapMode(m_mappingMode);
} // end of wxPMDCImpl::SetUserScale

void wxPMDCImpl::SetAxisOrientation( bool bXLeftRight,
                               bool bYBottomUp )
{
    m_signX = bXLeftRight ? 1 : -1;
    m_signY = bYBottomUp ? -1 : 1;

    SetMapMode(m_mappingMode);
} // end of wxPMDCImpl::SetAxisOrientation

void wxPMDCImpl::SetLogicalOrigin(
  wxCoord                           vX
, wxCoord                           vY
)
{
    RECTL                           vRect;

    ::GpiQueryPageViewport( m_hPS
                           ,&vRect
                          );
    vRect.xRight -= vX;
    vRect.yTop += vY;
    vRect.xLeft = vX;
    vRect.yBottom = vY;
    ::GpiSetPageViewport( m_hPS
                         ,&vRect
                        );
}; // end of wxPMDCImpl::SetLogicalOrigin

void wxPMDCImpl::SetDeviceOrigin(
  wxCoord                           vX
, wxCoord                           vY
)
{
    RECTL                           vRect;

    m_deviceOriginX = vX;
    m_deviceOriginY = vY;
    ::GpiQueryPageViewport( m_hPS
                           ,&vRect
                          );
    vRect.xLeft += vX;
    vRect.xRight += vX;
    vRect.yBottom -= vY;
    vRect.yTop -= vY;
    ::GpiSetPageViewport( m_hPS
                         ,&vRect
                        );
}; // end of wxPMDCImpl::SetDeviceOrigin

// ---------------------------------------------------------------------------
// bit blit
// ---------------------------------------------------------------------------

bool wxPMDCImpl::DoBlit( wxCoord vXdest,
                   wxCoord vYdest,
                   wxCoord vWidth,
                   wxCoord vHeight,
                   wxDC*   pSource,
                   wxCoord vXsrc,
                   wxCoord vYsrc,
                   wxRasterOperationMode     nRop,
                   bool    bUseMask,
                   wxCoord WXUNUSED(vXsrcMask),
                   wxCoord WXUNUSED(vYsrcMask) )
{
    wxMask*                         pMask = NULL;
    CHARBUNDLE                      vCbnd;
    COLORREF                        vOldTextColor;
    COLORREF                        vOldBackground = ::GpiQueryBackColor(m_hPS);

    wxDCImpl *impl = pSource->GetImpl();
    wxPMDCImpl *pm_impl = wxDynamicCast( impl, wxPMDCImpl );
    if (!pm_impl)
    {
        // TODO: Do we want to be able to blit
        //       from other DCs too?
        return false;
    }

    if (bUseMask)
    {
        const wxBitmap&             rBmp = pm_impl->GetSelectedBitmap();

        pMask = rBmp.GetMask();
        if (!(rBmp.IsOk() && pMask && pMask->GetMaskBitmap()))
        {
            bUseMask = false;
        }
    }

    ::GpiQueryAttrs( m_hPS
                    ,PRIM_CHAR
                    ,CBB_COLOR
                    ,&vCbnd
                   );
    vOldTextColor = (COLORREF)vCbnd.lColor;

    if (m_textForegroundColour.IsOk())
    {
        vCbnd.lColor = (LONG)m_textForegroundColour.GetPixel();
        ::GpiSetAttrs( m_hPS           // presentation-space handle
                      ,PRIM_CHAR       // Char primitive.
                      ,CBB_COLOR       // sets color.
                      ,0
                      ,&vCbnd          // buffer for attributes.
                     );
    }
    if (m_textBackgroundColour.IsOk())
    {
        ::GpiSetBackColor(m_hPS, (LONG)m_textBackgroundColour.GetPixel());
    }

    LONG                            lRop = ROP_SRCCOPY;

    switch (nRop)
    {
        case wxXOR:          lRop = ROP_SRCINVERT;        break;
        case wxINVERT:       lRop = ROP_DSTINVERT;        break;
        case wxOR_REVERSE:   lRop = 0x00DD0228;           break;
        case wxAND_REVERSE:  lRop = ROP_SRCERASE;         break;
        case wxCLEAR:        lRop = ROP_ZERO;             break;
        case wxSET:          lRop = ROP_ONE;              break;
        case wxOR_INVERT:    lRop = ROP_MERGEPAINT;       break;
        case wxAND:          lRop = ROP_SRCAND;           break;
        case wxOR:           lRop = ROP_SRCPAINT;         break;
        case wxEQUIV:        lRop = 0x00990066;           break;
        case wxNAND:         lRop = 0x007700E6;           break;
        case wxAND_INVERT:   lRop = 0x00220326;           break;
        case wxCOPY:         lRop = ROP_SRCCOPY;          break;
        case wxNO_OP:        lRop = ROP_NOTSRCERASE;      break;
        case wxSRC_INVERT:   lRop = ROP_SRCINVERT;        break;
        case wxNOR:          lRop = ROP_NOTSRCCOPY;       break;
        default:
           wxFAIL_MSG( wxT("unsupported logical function") );
           return false;
    }

    bool                            bSuccess;

    if (bUseMask)
    {
        //
        // Blit bitmap with mask
        //

        //
        // Create a temp buffer bitmap and DCs/PSs to access it and the mask
        //
        HDC                             hDCMask;
        HDC                             hDCBuffer;
        HPS                             hPSMask;
        HPS                             hPSBuffer;
        DEVOPENSTRUC                    vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
        BITMAPINFOHEADER2               vBmpHdr;
        HBITMAP                         hBufBitmap;
        SIZEL                           vSize = {0, 0};
        LONG                            rc;

        memset(&vBmpHdr, 0, sizeof(BITMAPINFOHEADER2));
        vBmpHdr.cbFix     = sizeof(BITMAPINFOHEADER2);
        vBmpHdr.cx        = vWidth;
        vBmpHdr.cy        = vHeight;
        vBmpHdr.cPlanes   = 1;
        vBmpHdr.cBitCount = 24;

#if wxUSE_DC_CACHEING
        {
            //
            // create a temp buffer bitmap and DCs to access it and the mask
            //
            wxDCCacheEntry*         pDCCacheEntry1    = FindDCInCache( NULL
                                                                      ,pm_impl->GetHPS()
                                                                     );
            wxDCCacheEntry*         pDCCacheEntry2    = FindDCInCache( pDCCacheEntry1
                                                                      ,GetHPS()
                                                                     );
            wxDCCacheEntry*         pBitmapCacheEntry = FindBitmapInCache( GetHPS()
                                                                          ,vWidth
                                                                          ,vHeight
                                                                         );

            hPSMask = pDCCacheEntry1->m_hPS;
            hDCBuffer = (HDC)pDCCacheEntry2->m_hPS;
            hBufBitmap = (HBITMAP)pBitmapCacheEntry->m_hBitmap;
            wxUnusedVar(hDCMask);
        }
#else
        {
            hDCMask = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
            hDCBuffer = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
            hPSMask = ::GpiCreatePS(vHabmain, hDCMask, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
            hPSBuffer = ::GpiCreatePS(vHabmain, hDCBuffer, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
            hBufBitmap = ::GpiCreateBitmap(GetHPS(), &vBmpHdr, 0L, NULL, NULL);
        }
#endif

        POINTL                          aPoint1[4] = { {0, 0}
                              ,{vWidth, vHeight}
                              ,{vXdest, vYdest}
                              ,{vXdest + vWidth, vYdest + vHeight}
                                                     };
        POINTL                          aPoint2[4] = { {0, 0}
                              ,{vWidth, vHeight}
                              ,{vXsrc, vYsrc}
                              ,{vXsrc + vWidth, vYsrc + vHeight}
                                                     };
        POINTL                          aPoint3[4] = { {vXdest, vYdest}
                              ,{vXdest + vWidth, vYdest + vHeight}
                              ,{vXsrc, vYsrc}
                              ,{vXsrc + vWidth, vYsrc + vHeight}
                                                     };
        POINTL                          aPoint4[4] = { {vXdest, vYdest}
                              ,{vXdest + vWidth, vYdest + vHeight}
                              ,{0, 0}
                              ,{vWidth, vHeight}
                                                     };
        ::GpiSetBitmap(hPSMask, (HBITMAP) pMask->GetMaskBitmap());
        ::GpiSetBitmap(hPSBuffer, (HBITMAP) hBufBitmap);

        //
        // Copy dest to buffer
        //
        rc = ::GpiBitBlt( hPSBuffer
                         ,GetHPS()
                         ,4L
                         ,aPoint1
                         ,ROP_SRCCOPY
                         ,BBO_IGNORE
                        );
        if (rc == GPI_ERROR)
        {
            wxLogLastError(wxT("BitBlt"));
        }

        //
        // Copy src to buffer using selected raster op
        //
        rc = ::GpiBitBlt( hPSBuffer
                         ,GetHPS()
                         ,4L
                         ,aPoint2
                         ,lRop
                         ,BBO_IGNORE
                        );
        if (rc == GPI_ERROR)
        {
            wxLogLastError(wxT("BitBlt"));
        }

        //
        // Set masked area in buffer to BLACK (pixel value 0)
        //
        COLORREF                        vPrevBkCol = ::GpiQueryBackColor(GetHPS());
        COLORREF                        vPrevCol = ::GpiQueryColor(GetHPS());

        ::GpiSetBackColor(GetHPS(), OS2RGB(255, 255, 255));
        ::GpiSetColor(GetHPS(), OS2RGB(0, 0, 0));

        rc = ::GpiBitBlt( hPSBuffer
                         ,hPSMask
                         ,4L
                         ,aPoint2
                         ,ROP_SRCAND
                         ,BBO_IGNORE
                        );
        if (rc == GPI_ERROR)
        {
            wxLogLastError(wxT("BitBlt"));
        }

        //
        // Set unmasked area in dest to BLACK
        //
        ::GpiSetBackColor(GetHPS(), OS2RGB(0, 0, 0));
        ::GpiSetColor(GetHPS(), OS2RGB(255, 255, 255));
        rc = ::GpiBitBlt( GetHPS()
                         ,hPSMask
                         ,4L
                         ,aPoint3
                         ,ROP_SRCAND
                         ,BBO_IGNORE
                        );
        if (rc == GPI_ERROR)
        {
            wxLogLastError(wxT("BitBlt"));
        }

        //
        // Restore colours to original values
        //
        ::GpiSetBackColor(GetHPS(), vPrevBkCol);
        ::GpiSetColor(GetHPS(), vPrevCol);

        //
        // OR buffer to dest
        //
        rc = ::GpiBitBlt( GetHPS()
                         ,hPSMask
                         ,4L
                         ,aPoint4
                         ,ROP_SRCPAINT
                         ,BBO_IGNORE
                        );
        if (rc == GPI_ERROR)
        {
            bSuccess = false;
            wxLogLastError(wxT("BitBlt"));
        }

        //
        // Tidy up temporary DCs and bitmap
        //
        ::GpiSetBitmap(hPSMask, NULLHANDLE);
        ::GpiSetBitmap(hPSBuffer, NULLHANDLE);
#if !wxUSE_DC_CACHEING
        ::GpiDestroyPS(hPSMask);
        ::GpiDestroyPS(hPSBuffer);
        ::DevCloseDC(hDCMask);
        ::DevCloseDC(hDCBuffer);
        ::GpiDeleteBitmap(hBufBitmap);
#endif
        bSuccess = true;
    }
    else // no mask, just BitBlt() it
    {
      POINTL                          aPoint[4] = { {vXdest, vYdest}
                           ,{vXdest + vWidth, vYdest + vHeight}
                           ,{vXsrc, vYsrc}
                           ,{vXsrc + vWidth, vYsrc + vHeight}
                                                    };

        bSuccess = (::GpiBitBlt( m_hPS
                                ,pm_impl->GetHPS()
                                ,4L
                                ,aPoint
                                ,lRop
                                ,BBO_IGNORE
                               ) != GPI_ERROR);
        if (!bSuccess )
        {
            wxLogLastError(wxT("BitBlt"));
        }
    }
    vCbnd.lColor = (LONG)vOldTextColor;
    ::GpiSetAttrs( m_hPS           // presentation-space handle
                  ,PRIM_CHAR       // Char primitive.
                  ,CBB_COLOR       // sets color.
                  ,0
                  ,&vCbnd          // buffer for attributes.
                 );
    ::GpiSetBackColor(m_hPS, (LONG)vOldBackground);
    return bSuccess;
}

void wxPMDCImpl::DoGetSize( int* pnWidth,
                            int* pnHeight ) const
{
    LONG lArray[CAPS_HEIGHT+1];

    if(::DevQueryCaps( m_hDC
                      ,CAPS_FAMILY
                      ,CAPS_HEIGHT+1
                      ,lArray
                     ))
    {
        if (pnWidth)
            *pnWidth  = lArray[CAPS_WIDTH];
        if (pnHeight)
            *pnHeight = lArray[CAPS_HEIGHT];
    }
}; // end of wxPMDCImpl::DoGetSize(

void wxPMDCImpl::DoGetSizeMM( int* pnWidth,
                        int* pnHeight ) const
{
    LONG                            lArray[CAPS_VERTICAL_RESOLUTION+1];

    if(::DevQueryCaps( m_hDC
                      ,CAPS_FAMILY
                      ,CAPS_VERTICAL_RESOLUTION+1
                      ,lArray
                     ))
    {
        if(pnWidth)
        {
            int nWidth   = lArray[CAPS_WIDTH];
            int nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
            // use fp to avoid returning 0 if nHorzRes < 1000
            *pnWidth  = (int)((nHorzRes/1000.0) * nWidth);
        }

        if(pnHeight)
        {
            int nHeight  = lArray[CAPS_HEIGHT];
            int nVertRes = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
            // use fp to avoid returning 0 if nVertRes < 1000
            *pnHeight = (int)((nVertRes/1000.0) * nHeight);
        }
    }
}; // end of wxPMDCImpl::DoGetSizeMM

wxSize wxPMDCImpl::GetPPI() const
{
    LONG                            lArray[CAPS_VERTICAL_RESOLUTION+1];
    int                             nWidth = 0;
    int                             nHeight = 0;

    if(::DevQueryCaps( m_hDC
                      ,CAPS_FAMILY
                      ,CAPS_VERTICAL_RESOLUTION+1
                      ,lArray
                     ))
    {
        int                         nPelWidth;
        int                         nPelHeight;
        int                         nHorzRes;
        int                         nVertRes;

        nPelWidth  = lArray[CAPS_WIDTH];
        nPelHeight = lArray[CAPS_HEIGHT];
        nHorzRes   = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
        nVertRes   = lArray[CAPS_VERTICAL_RESOLUTION];   // returns pel/meter
        nWidth   = (int)((nHorzRes/39.3) * nPelWidth);
        nHeight  = (int)((nVertRes/39.3) * nPelHeight);
    }
    wxSize ppisize(nWidth, nHeight);
    return ppisize;
} // end of wxPMDCImpl::GetPPI

void wxPMDCImpl::SetLogicalScale( double dX, double dY )
{
    m_logicalScaleX = dX;
    m_logicalScaleY = dY;
}; // end of wxPMDCImpl::SetLogicalScale
