]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/dc.cpp
Added stub for the new pure virtual DoInsert method
[wxWidgets.git] / src / os2 / dc.cpp
index 87610e6d630db806036c0933e98e0d99edc74723..9715d7754c2a960649f572d0faa61814257a6703 100644 (file)
@@ -24,6 +24,9 @@
     #include "wx/icon.h"
     #include "wx/msgdlg.h"
     #include "wx/module.h"
     #include "wx/icon.h"
     #include "wx/msgdlg.h"
     #include "wx/module.h"
+#if wxUSE_STATUSBAR
+    #include "wx/statusbr.h"
+#endif
 #endif
 
 #include "wx/dcprint.h"
 #endif
 
 #include "wx/dcprint.h"
@@ -659,14 +662,38 @@ void wxDC::DoDrawLine(
 )
 {
     POINTL                          vPoint[2];
 )
 {
     POINTL                          vPoint[2];
+    COLORREF                        vColor = 0x00ffffff;
 
 
-    vY1 = OS2Y(vY1,0);
-    vY2 = OS2Y(vY2,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))
+    {
+        vY1 = OS2Y(vY1,0);
+        vY2 = OS2Y(vY2,0);
+    }
+    else
+    {
+        if (m_vSelectedBitmap != wxNullBitmap)
+        {
+            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;
     vPoint[0].x = vX1;
     vPoint[0].y = vY1;
     vPoint[1].x = vX2;
     vPoint[1].y = vY2;
+    if (m_pen.Ok())
+    {
+        vColor = m_pen.GetColour().GetPixel();
+    }
+    ::GpiSetColor(m_hPS, vColor);
     ::GpiMove(m_hPS, &vPoint[0]);
     ::GpiLine(m_hPS, &vPoint[1]);
     CalcBoundingBox(vX1, vY1);
     ::GpiMove(m_hPS, &vPoint[0]);
     ::GpiLine(m_hPS, &vPoint[1]);
     CalcBoundingBox(vX1, vY1);
@@ -979,13 +1006,22 @@ void wxDC::DoDrawRectangle(
     int                             nIsTRANSPARENT = 0;
 
     //
     int                             nIsTRANSPARENT = 0;
 
     //
-    // Might be a memory DC with no Paint rect
+    // 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);
     //
     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 != wxNullBitmap)
+        {
+            m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
+            m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
+            vY = OS2Y(vY,vHeight);
+        }
+    }
 
     wxCoord                         vX2 = vX + vWidth;
     wxCoord                         vY2 = vY + vHeight;
 
     wxCoord                         vX2 = vX + vWidth;
     wxCoord                         vY2 = vY + vHeight;
@@ -1005,7 +1041,7 @@ void wxDC::DoDrawRectangle(
         if(m_brush.GetStyle() == wxTRANSPARENT)
             lControl = DRO_OUTLINE;
 
         if(m_brush.GetStyle() == wxTRANSPARENT)
             lControl = DRO_OUTLINE;
 
-        ::GpiSetColor(m_hPS, lColor);
+        ::GpiSetColor(m_hPS, lBorderColor);
         ::GpiBox( m_hPS       // handle to a presentation space
                  ,lControl   // draw the box outline ? or ?
                  ,&vPoint[1]  // address of the corner
         ::GpiBox( m_hPS       // handle to a presentation space
                  ,lControl   // draw the box outline ? or ?
                  ,&vPoint[1]  // address of the corner
@@ -1055,27 +1091,85 @@ void wxDC::DoDrawRoundedRectangle(
 {
     POINTL                          vPoint[2];
     LONG                            lControl;
 {
     POINTL                          vPoint[2];
     LONG                            lControl;
+    LONG                            lColor;
+    LONG                            lBorderColor;
+    int                             nIsTRANSPARENT = 0;
 
 
-    vY = OS2Y(vY,vHeight);
+    //
+    // 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 != wxNullBitmap)
+        {
+            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;
 
     wxCoord                         vX2 = (vX + vWidth);
     wxCoord                         vY2 = (vY + vHeight);
 
     vPoint[0].x = vX;
-    vPoint[0].y = YLOG2DEV(vY) - vHeight;
-    vPoint[1].x = vX + vWidth;
-    vPoint[1].y = vY;
+    vPoint[0].y = vY;
+    vPoint[1].x = vX + vWidth - 1;
+    vPoint[1].y = vY + vHeight - 1;
     ::GpiMove(m_hPS, &vPoint[0]);
 
     ::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)
     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;
         lControl = DRO_OUTLINE;
-    ::GpiBox( m_hPS         // handle to a presentation space
-             ,DRO_OUTLINE   // draw the box outline ? or ?
-             ,&vPoint[1]    // address of the corner
-             ,(LONG)dRadius // horizontal corner radius
-             ,(LONG)dRadius // vertical corner radius
-            );
+        ::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 wxDC::DoDrawRoundedRectangle
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX2, vY2);
 } // end of wxDC::DoDrawRoundedRectangle
@@ -1189,15 +1283,21 @@ void wxDC::DoDrawIcon(
 , wxCoord                           vY
 )
 {
 , wxCoord                           vY
 )
 {
-    vY = OS2Y(vY,rIcon.GetHeight());
-    wxCHECK_RET( rIcon.Ok(), wxT("invalid icon in DrawIcon") );
+    //
+    // 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 routing display it
+    //
+    if (rIcon.IsXpm())
+    {
+        DoDrawBitmap(rIcon.GetXpmSrc(), vX, vY, TRUE);
+    }
+    else
+    {
+        wxBitmap                        vBitmap(rIcon);
 
 
-    ::WinDrawPointer( GetHPS()
-                     ,vX
-                     ,vY
-                     ,(HPOINTER)GetHiconOf(rIcon)
-                     ,DP_NORMAL
-                    );
+        DoDrawBitmap(vBitmap, vX, vY, FALSE);
+    }
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
 } // end of wxDC::DoDrawIcon
     CalcBoundingBox(vX, vY);
     CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
 } // end of wxDC::DoDrawIcon
@@ -1212,142 +1312,389 @@ void wxDC::DoDrawBitmap(
     if (!IsKindOf(CLASSINFO(wxPrinterDC)))
     {
         HBITMAP                         hBitmap =  (HBITMAP)rBmp.GetHBITMAP();
     if (!IsKindOf(CLASSINFO(wxPrinterDC)))
     {
         HBITMAP                         hBitmap =  (HBITMAP)rBmp.GetHBITMAP();
-        wxBitmap                        vNewBitmap( rBmp.GetWidth()
-                                                   ,rBmp.GetHeight()
-                                                   ,rBmp.GetDepth()
-                                                  );
-        HBITMAP                         hBitmapOld = ::GpiSetBitmap((HPS)GetHPS(), vNewBitmap.GetHBITMAP());
-        LONG                            lOldTextground = ::GpiQueryColor((HPS)GetHPS());
-        LONG                            lOldBackground = ::GpiQueryBackColor((HPS)GetHPS());
+        HBITMAP                         hBitmapOld;
+        POINTL                          vPoint[4];
 
         vY = OS2Y(vY,rBmp.GetHeight());
 
 
         vY = OS2Y(vY,rBmp.GetHeight());
 
-        //
-        // Flip the picture as OS/2 is upside-down
-        //
-        POINTL                      vPoint[4] = { vX, vY + rBmp.GetHeight()
-                                                 ,vX + rBmp.GetWidth(), vY
-                                                 ,0, 0
-                                                 ,rBmp.GetWidth(), rBmp.GetHeight()
-                                                };
-
-        if (m_textForegroundColour.Ok())
-        {
-            ::GpiSetColor( (HPS)GetHPS()
-                           ,m_textForegroundColour.GetPixel()
-                          );
-        }
-        if (m_textBackgroundColour.Ok())
-        {
-            ::GpiSetBackColor( (HPS)GetHPS()
-                              ,m_textBackgroundColour.GetPixel()
-                             );
-        }
+        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 (bUseMask)
         {
             wxMask*                     pMask = rBmp.GetMask();
-            HPS                         hPS;
-            HDC                         hDC;
 
 
-            if (!IsKindOf(CLASSINFO(wxMemoryDC)))
+            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};
                 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);
 
 
-                hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
-                hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
-            }
-            else
-                hPS = m_hPS;
+                //
+                // The usual bitmap header stuff
+                //
+                BITMAPINFOHEADER2               vHeader;
+                BITMAPINFO2                     vInfo;
 
 
-            if (pMask)
-            {
-                BITMAPINFOHEADER2           vHeader;
-                BITMAPINFO2                 vInfo;
-                int                         nBytesPerLine = rBmp.GetWidth() * 3;
-                unsigned char*              pucData;
-                LONG                        lScans = 0L;
-                LONG                        alFormats[24]; // Max formats OS/2 PM supports
-                ULONG                       ulBitcount;
-                HBITMAP                     hMask = (HBITMAP)pMask->GetMaskBitmap();
-                POINTL                      vPointMask[4] = { 0, 0, rBmp.GetWidth(), rBmp.GetHeight()
-                                                             ,0, 0, rBmp.GetWidth(), rBmp.GetHeight()
-                                                            };
-
-                ::GpiSetBitmap(hPS, hMask);
-
-                ::GpiQueryDeviceBitmapFormats(hPS, 24, alFormats);
-                ulBitcount = alFormats[1]; // the best one
-                if (ulBitcount > 24) // PM supports a max of 24
-                    ulBitcount = 24;
-
-                vInfo.cbFix     = 16;
-                vInfo.cx        = rBmp.GetWidth();
-                vInfo.cy        = rBmp.GetHeight();
-                vInfo.cPlanes   = 1;
-                vInfo.cBitCount = ulBitcount;
-                pucData = (unsigned char*)malloc(nBytesPerLine * rBmp.GetHeight());
+                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(wxWindowDC)))
+                {
+                    wxWindowDC*             pWindowDC = wxDynamicCast(this, wxWindowDC);
+
+                    lColor = pWindowDC->m_pCanvas->GetBackgroundColour().GetPixel();
+                }
+                else if (GetBrush() != wxNullBrush)
+                    lColor = GetBrush().GetColour().GetPixel();
+                else
+                    lColor = m_textBackgroundColour.GetPixel();
+
+                //
+                // Bitmap must be ina double-word alligned 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()
                 if ((lScans = ::GpiQueryBitmapBits( hPS
                                                    ,0L
                                                    ,(LONG)rBmp.GetHeight()
-                                                   ,(PBYTE)pucData
+                                                   ,(PBYTE)pucBits
                                                    ,&vInfo
                                                   )) == GPI_ALTERROR)
                 {
                                                    ,&vInfo
                                                   )) == GPI_ALTERROR)
                 {
-                    ERRORID                     vError;
-                    wxString                    sError;
-
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
-                if ((hBitmapOld = ::GpiSetBitmap(hPS, (HBITMAP)vNewBitmap.GetHBITMAP())) == HBM_ERROR)
+                if ((hOldMask = ::GpiSetBitmap(hPS, hMask)) == HBM_ERROR)
                 {
                 {
-                    ERRORID                     vError;
-                    wxString                    sError;
-
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
-                if ((lScans = ::GpiSetBitmapBits( hPS
-                                                 ,0
-                                                 ,(LONG)rBmp.GetHeight()
-                                                 ,(PBYTE)pucData
-                                                 ,&vInfo
-                                                )) == GPI_ALTERROR)
+                ::GpiQueryBitmapInfoHeader(hMask, &vHeader);
+                vInfo.cBitCount = 24;
+                if ((lScans = ::GpiQueryBitmapBits( hPS
+                                                   ,0L
+                                                   ,(LONG)rBmp.GetHeight()
+                                                   ,(PBYTE)pucBitsMask
+                                                   ,&vInfo
+                                                  )) == GPI_ALTERROR)
                 {
                 {
-                    ERRORID                 vError;
-                    wxString                sError;
-
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
-                if ((hBitmapOld = ::GpiSetBitmap(hPS, NULLHANDLE)) == HBM_ERROR)
+                if (( hMask = ::GpiSetBitmap(hPS, hOldMask)) == HBM_ERROR)
                 {
                 {
-                    ERRORID                     vError;
-                    wxString                    sError;
-
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
-                if ((hBitmapOld = ::GpiSetBitmap((HPS)GetHPS(), vNewBitmap.GetHBITMAP())) == HBM_ERROR)
+
+                //
+                // 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)
                 {
                 {
-                    ERRORID                     vError;
-                    wxString                    sError;
+                    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);
                 }
                     vError = ::WinGetLastError(vHabmain);
                     sError = wxPMErrorToStr(vError);
                 }
-                ::GpiWCBitBlt( (HPS)GetHPS()
-                              ,hBitmap
-                              ,4
-                              ,vPoint
-                              ,ROP_SRCAND
-                              ,BBO_IGNORE
-                             );
+
+                //
+                // Clean up
+                //
+                free(pucBits);
+                free(pucBitsMask);
+                ::GpiSetBitmap(hPS, NULLHANDLE);
+                ::GpiDeleteBitmap(hNewBitmap);
+                ::GpiDestroyPS(hPS);
+                ::DevCloseDC(hDC);
             }
         }
         else
         {
             }
         }
         else
         {
+            LONG                        lOldForeGround = ::GpiQueryColor((HPS)GetHPS());
+            LONG                        lOldBackGround = ::GpiQueryBackColor((HPS)GetHPS());
+
+            if (m_textForegroundColour.Ok())
+            {
+                ::GpiSetColor( (HPS)GetHPS()
+                               ,m_textForegroundColour.GetPixel()
+                              );
+            }
+            if (m_textBackgroundColour.Ok())
+            {
+                ::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);
+                    return;
+                }
+                if ((lScans = ::GpiQueryBitmapBits( hPS
+                                                   ,0L
+                                                   ,(LONG)rBmp.GetHeight()
+                                                   ,(PBYTE)pucBits
+                                                   ,&vInfo
+                                                  )) == GPI_ALTERROR)
+                {
+                    vError = ::WinGetLastError(vHabmain);
+                    sError = wxPMErrorToStr(vError);
+                    return;
+                }
+                unsigned char           cOldRedFore   = (unsigned char)(lOldForeGround >> 16);
+                unsigned char           cOldGreenFore = (unsigned char)(lOldForeGround >> 8);
+                unsigned char           cOldBlueFore  = (unsigned char)lOldForeGround;
+
+                unsigned char           cOldRedBack   = (unsigned char)(lOldBackGround >> 16);
+                unsigned char           cOldGreenBack = (unsigned char)(lOldBackGround >> 8);
+                unsigned char           cOldBlueBack  = (unsigned char)lOldBackGround;
+
+                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
             ::GpiWCBitBlt( (HPS)GetHPS()
                           ,hBitmap
                           ,4
@@ -1355,10 +1702,10 @@ void wxDC::DoDrawBitmap(
                           ,ROP_SRCCOPY
                           ,BBO_IGNORE
                          );
                           ,ROP_SRCCOPY
                           ,BBO_IGNORE
                          );
+            ::GpiSetBitmap((HPS)GetHPS(), hBitmapOld);
+            ::GpiSetColor((HPS)GetHPS(), lOldForeGround);
+            ::GpiSetBackColor((HPS)GetHPS(), lOldBackGround);
         }
         }
-        ::GpiSetBitmap((HPS)GetHPS(), hBitmapOld);
-        ::GpiSetColor((HPS)GetHPS(), lOldTextground);
-        ::GpiSetBackColor((HPS)GetHPS(), lOldBackground);
     }
 } // end of wxDC::DoDrawBitmap
 
     }
 } // end of wxDC::DoDrawBitmap
 
@@ -1421,13 +1768,41 @@ void wxDC::DrawAnyText(
                   ,&vTextY
                  );
     vPtlStart.x = vX;
                   ,&vTextY
                  );
     vPtlStart.x = vX;
-    vPtlStart.y = OS2Y(vY,vTextY);
+    if (!(m_vRclPaint.yTop == 0 &&
+          m_vRclPaint.yBottom == 0 &&
+          m_vRclPaint.xRight == 0 &&
+          m_vRclPaint.xLeft == 0))
+    {
+        //
+        // Position Text a little differently in the Statusbar from other panels
+        //
+        if (m_pCanvas && m_pCanvas->IsKindOf(CLASSINFO(wxStatusBar)))
+            vPtlStart.y = OS2Y(vY,vTextY);
+        else
+            vPtlStart.y = OS2Y(vY,vTextY/1.5); // Full extent is a bit much
+    }
+    else
+    {
+        if (m_vSelectedBitmap != wxNullBitmap)
+        {
+            m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
+            m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
+            if (m_pCanvas && m_pCanvas->IsKindOf(CLASSINFO(wxStatusBar)))
+                vPtlStart.y = OS2Y(vY,vTextY);
+            else
+                vPtlStart.y = OS2Y(vY,vTextY/1.5);
+        }
+        else
+            vPtlStart.y = vY;
+    }
 
 
-    lHits = ::GpiCharStringAt( m_hPS
-                              ,&vPtlStart
-                              ,rsText.length()
-                              ,(PCH)rsText.c_str()
-                             );
+    PCH                             pzStr = (PCH)rsText.c_str();
+
+    ::GpiMove(m_hPS, &vPtlStart);
+    lHits = ::GpiCharString( m_hPS
+                            ,rsText.length()
+                            ,pzStr
+                           );
     if (lHits != GPI_OK)
     {
         wxLogLastError(wxT("TextOut"));
     if (lHits != GPI_OK)
     {
         wxLogLastError(wxT("TextOut"));
@@ -1650,6 +2025,7 @@ void wxDC::SetPen(
             if (!m_hOldPen)
                 m_hOldPen = m_pen.GetPS();
         }
             if (!m_hOldPen)
                 m_hOldPen = m_pen.GetPS();
         }
+        ::GpiSetColor(m_hPS, m_pen.GetColour().GetPixel());
     }
 }
 
     }
 }
 
@@ -2511,18 +2887,5 @@ void wxDC::SetLogicalScale(
     m_logicalScaleY = dY;
 }; // end of wxDC::SetLogicalScale
 
     m_logicalScaleY = dY;
 }; // end of wxDC::SetLogicalScale
 
-#if WXWIN_COMPATIBILITY
-void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
-                         float *descent, float *externalLeading,
-                         wxFont *theFont, bool use16bit) const
-{
-    wxCoord x1, y1, descent1, externalLeading1;
-    GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
-    *x = x1; *y = y1;
-    if (descent)
-        *descent = descent1;
-    if (externalLeading)
-        *externalLeading = externalLeading1;
-}
-#endif
+