]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/bitmap.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Moved #if wxUSE_COMBOBOX after real wx/wxprec.h include.
[wxWidgets.git] / src / os2 / bitmap.cpp
diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp
index 53a1a01dc941bc3b52bf027ce9c865a216171f63..9d81414df6f7f150183a2d461e298f82d3670ce9 100644 (file)
--- a/src/os2/bitmap.cpp
+++ b/src/os2/bitmap.cpp
@@ -58,14 +58,15 @@ wxBitmapRefData::wxBitmapRefData()
     m_pSelectedInto = NULL;
     m_nNumColors    = 0;
     m_pBitmapMask   = NULL;
     m_pSelectedInto = NULL;
     m_nNumColors    = 0;
     m_pBitmapMask   = NULL;
-    m_hBitmap = (WXHBITMAP) NULL;
+    m_hBitmap       = (WXHBITMAP) NULL;
 } // end of wxBitmapRefData::wxBitmapRefData
 
 void wxBitmapRefData::Free()
 {
 } // end of wxBitmapRefData::wxBitmapRefData
 
 void wxBitmapRefData::Free()
 {
-    wxASSERT_MSG( !m_pSelectedInto,
-                  wxT("deleting bitmap still selected into wxMemoryDC") );
-
+    if ( m_pSelectedInto )
+    {
+        wxLogLastError("GpiDeleteBitmap(hbitmap)");
+    }
     if (m_hBitmap)
     {
         if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
     if (m_hBitmap)
     {
         if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
@@ -73,9 +74,11 @@ void wxBitmapRefData::Free()
             wxLogLastError("GpiDeleteBitmap(hbitmap)");
         }
     }
             wxLogLastError("GpiDeleteBitmap(hbitmap)");
         }
     }
-
-    delete m_pBitmapMask;
-    m_pBitmapMask = NULL;
+    if (m_pBitmapMask)
+    {
+        delete m_pBitmapMask;
+        m_pBitmapMask = NULL;
+    }
 } // end of wxBitmapRefData::Free
 
 // ----------------------------------------------------------------------------
 } // end of wxBitmapRefData::Free
 
 // ----------------------------------------------------------------------------
@@ -85,6 +88,10 @@ void wxBitmapRefData::Free()
 // this function should be called from all wxBitmap ctors
 void wxBitmap::Init()
 {
 // this function should be called from all wxBitmap ctors
 void wxBitmap::Init()
 {
+    m_bIsMono = FALSE;
+    //
+    // True for all bitmaps created from bits, wxImages, Xpms
+    //
 } // end of wxBitmap::Init
 
 bool wxBitmap::CopyFromIconOrCursor(
 } // end of wxBitmap::Init
 
 bool wxBitmap::CopyFromIconOrCursor(
@@ -112,9 +119,11 @@ bool wxBitmap::CopyFromIconOrCursor(
 
     pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
 
 
     pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
 
-    //
-    // No mask in the Info struct in OS/2
-    //
+    wxMask*                         pMask = new wxMask(SIconInfo.hbmPointer);
+
+    pMask->SetMaskBitmap(GetHBITMAP());
+    SetMask(pMask);
+
     return(TRUE);
 } // end of wxBitmap::CopyFromIconOrCursor
 
     return(TRUE);
 } // end of wxBitmap::CopyFromIconOrCursor
 
@@ -173,7 +182,7 @@ wxBitmap::wxBitmap(
     pRefData->m_nNumColors    = 0;
     pRefData->m_pSelectedInto = NULL;
 
     pRefData->m_nNumColors    = 0;
     pRefData->m_pSelectedInto = NULL;
 
-    hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+    hDc   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
     if (hPs == 0)
     {
     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
     if (hPs == 0)
     {
@@ -226,31 +235,22 @@ wxBitmap::wxBitmap(
         pzData = (char *)zBits;    // const_cast is harmless
     }
 
         pzData = (char *)zBits;    // const_cast is harmless
     }
 
-    memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
-    vHeader.cbFix           = sizeof(vHeader);
+    if (nDepth > 24)
+        nDepth = 24; // MAX supported in PM
+    memset(&vHeader, '\0', 16);
+    vHeader.cbFix           = 16;
     vHeader.cx              = (USHORT)nWidth;
     vHeader.cy              = (USHORT)nHeight;
     vHeader.cPlanes         = 1L;
     vHeader.cBitCount       = nDepth;
     vHeader.usReserved      = 0;
     vHeader.cx              = (USHORT)nWidth;
     vHeader.cy              = (USHORT)nHeight;
     vHeader.cPlanes         = 1L;
     vHeader.cBitCount       = nDepth;
     vHeader.usReserved      = 0;
-    vHeader.ulCompression   = BCA_UNCOMP;
-    vHeader.usRecording     = BRA_BOTTOMUP;
-    vHeader.usRendering     = BRH_NOTHALFTONED;
-    vHeader.ulColorEncoding = BCE_RGB;
-    vHeader.ulIdentifier    = 0;
-
-    memset(&vInfo, '\0', sizeof(BITMAPINFO2));
-    vInfo.cbFix           = sizeof(vInfo);
+
+    memset(&vInfo, '\0', 16);
+    vInfo.cbFix           = 16;
     vInfo.cx              = (USHORT)nWidth;
     vInfo.cy              = (USHORT)nHeight;
     vInfo.cPlanes         = 1L;
     vInfo.cBitCount       = nDepth;
     vInfo.cx              = (USHORT)nWidth;
     vInfo.cy              = (USHORT)nHeight;
     vInfo.cPlanes         = 1L;
     vInfo.cBitCount       = nDepth;
-    vInfo.usReserved      = 0;
-    vInfo.ulCompression   = BCA_UNCOMP;
-    vInfo.usRecording     = BRA_BOTTOMUP;
-    vInfo.usRendering     = BRH_NOTHALFTONED;
-    vInfo.ulColorEncoding = BCE_RGB;
-    vInfo.ulIdentifier    = 0;
 
     HBITMAP                         hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
 
 
     HBITMAP                         hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
 
@@ -258,7 +258,8 @@ wxBitmap::wxBitmap(
     {
         wxLogLastError("CreateBitmap");
     }
     {
         wxLogLastError("CreateBitmap");
     }
-    ::WinReleasePS(hPs);
+    ::GpiDestroyPS(hPs);
+    ::DevCloseDC(hDc);
     SetHBITMAP((WXHBITMAP)hBmp);
 } // end of wxBitmap::wxBitmap
 
     SetHBITMAP((WXHBITMAP)hBmp);
 } // end of wxBitmap::wxBitmap
 
@@ -269,7 +270,6 @@ wxBitmap::wxBitmap(
 )
 {
     Init();
 )
 {
     Init();
-
     (void)Create( nW
                  ,nH
                  ,nD
     (void)Create( nW
                  ,nH
                  ,nD
@@ -295,15 +295,15 @@ wxBitmap::wxBitmap(
 } // end of wxBitmap::wxBitmap
 
 wxBitmap::wxBitmap(
 } // end of wxBitmap::wxBitmap
 
 wxBitmap::wxBitmap(
-  const wxString&                   rFilename
+  int                               nId
 , long                              lType
 )
 {
     Init();
 , long                              lType
 )
 {
     Init();
-
-    LoadFile( rFilename
+    LoadFile( nId
              ,(int)lType
             );
              ,(int)lType
             );
+    SetId(nId);
 } // end of wxBitmap::wxBitmap
 
 bool wxBitmap::Create(
 } // end of wxBitmap::wxBitmap
 
 bool wxBitmap::Create(
@@ -322,6 +322,10 @@ bool wxBitmap::Create(
     GetBitmapData()->m_nHeight = nH;
     GetBitmapData()->m_nDepth = nD;
 
     GetBitmapData()->m_nHeight = nH;
     GetBitmapData()->m_nDepth = nD;
 
+    //
+    // Xpms and bitmaps from other images can also be mono's, but only
+    // mono's need help changing their colors with MemDC changes
+    //
     if (nD > 0)
     {
         DEVOPENSTRUC                vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
     if (nD > 0)
     {
         DEVOPENSTRUC                vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
@@ -329,12 +333,14 @@ bool wxBitmap::Create(
         HDC                         hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
         HPS                         hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 
         HDC                         hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
         HPS                         hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 
-        memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
-        vHeader.cbFix     =  sizeof(BITMAPINFOHEADER2);
+        if (nD == 1)
+            m_bIsMono = TRUE;
+        memset(&vHeader, '\0', 16);
+        vHeader.cbFix     =  16;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;
-        vHeader.cBitCount = nD;
+        vHeader.cBitCount = 24; //nD;
 
         hBmp = ::GpiCreateBitmap( hPS
                                  ,&vHeader
 
         hBmp = ::GpiCreateBitmap( hPS
                                  ,&vHeader
@@ -355,8 +361,11 @@ bool wxBitmap::Create(
         hDCScreen = ::GpiQueryDevice(hPSScreen);
         ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 
         hDCScreen = ::GpiQueryDevice(hPSScreen);
         ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 
-        memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
-        vHeader.cbFix     =  sizeof(BITMAPINFOHEADER2);
+        if (lBitCount > 24)
+            lBitCount = 24;
+
+        memset(&vHeader, '\0', 16);
+        vHeader.cbFix     =  16;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;
@@ -374,10 +383,6 @@ bool wxBitmap::Create(
     }
     SetHBITMAP((WXHBITMAP)hBmp);
 
     }
     SetHBITMAP((WXHBITMAP)hBmp);
 
-#if WXWIN_COMPATIBILITY_2
-    GetBitmapData()->m_bOk = hBmp != 0;
-#endif // WXWIN_COMPATIBILITY_2
-
     return Ok();
 } // end of wxBitmap::Create
 
     return Ok();
 } // end of wxBitmap::Create
 
@@ -403,12 +408,10 @@ bool wxBitmap::CreateFromXpm(
 } // end of wxBitmap::CreateFromXpm
 
 bool wxBitmap::LoadFile(
 } // end of wxBitmap::CreateFromXpm
 
 bool wxBitmap::LoadFile(
-  const wxString&                   rFilename
+  int                               nId
 , long                              lType
 )
 {
 , long                              lType
 )
 {
-    HPS                             hPs = NULLHANDLE;
-
     UnRef();
 
     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
     UnRef();
 
     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
@@ -420,8 +423,7 @@ bool wxBitmap::LoadFile(
         m_refData = new wxBitmapRefData;
 
         return(pHandler->LoadFile( this
         m_refData = new wxBitmapRefData;
 
         return(pHandler->LoadFile( this
-                                  ,rFilename
-                                  ,hPs
+                                  ,nId
                                   ,lType
                                   , -1
                                   , -1
                                   ,lType
                                   , -1
                                   , -1
@@ -429,14 +431,7 @@ bool wxBitmap::LoadFile(
     }
     else
     {
     }
     else
     {
-        wxImage                     vImage;
-
-        if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
-            return(FALSE);
-
-        *this = wxBitmap(vImage);
-
-        return(TRUE);
+        return(FALSE);
     }
 } // end of wxBitmap::LoadFile
 
     }
 } // end of wxBitmap::LoadFile
 
@@ -456,8 +451,7 @@ bool wxBitmap::Create(
 
     if (!pHandler)
     {
 
     if (!pHandler)
     {
-        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
-                       "type %d defined."), lType);
+        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), lType);
 
         return(FALSE);
     }
 
         return(FALSE);
     }
@@ -507,7 +501,7 @@ bool wxBitmap::SaveFile(
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
-// wxImage-wxBitmap convertion
+// wxImage-wxBitmap conversion
 // ----------------------------------------------------------------------------
 
 bool wxBitmap::CreateFromImage (
 // ----------------------------------------------------------------------------
 
 bool wxBitmap::CreateFromImage (
@@ -555,6 +549,10 @@ bool wxBitmap::CreateFromImage (
     wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
     SetWidth(nWidth);
     SetHeight(nBmpHeight);
     wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
     SetWidth(nWidth);
     SetHeight(nBmpHeight);
+    if (nDepth == 1)
+        m_bIsMono = TRUE;
+    else
+        m_bIsMono = FALSE;
     if (nDepth == -1)
         nDepth = wxDisplayDepth();
     SetDepth(nDepth);
     if (nDepth == -1)
         nDepth = wxDisplayDepth();
     SetDepth(nDepth);
@@ -570,46 +568,30 @@ bool wxBitmap::CreateFromImage (
     // Create a DIB header
     //
     BITMAPINFOHEADER2               vHeader;
     // Create a DIB header
     //
     BITMAPINFOHEADER2               vHeader;
+    BITMAPINFO2                     vInfo;
 
     //
     // Fill in the DIB header
     //
 
     //
     // Fill in the DIB header
     //
-    memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
-    vHeader.cbFix           = sizeof(vHeader);
-    vHeader.cx              = (USHORT)nWidth;
-    vHeader.cy              = (USHORT)nHeight;
+    memset(&vHeader, '\0', 16);
+    vHeader.cbFix           = 16;
+    vHeader.cx              = (ULONG)nWidth;
+    vHeader.cy              = (ULONG)nHeight;
     vHeader.cPlanes         = 1L;
     vHeader.cBitCount       = 24;
     vHeader.cPlanes         = 1L;
     vHeader.cBitCount       = 24;
-    vHeader.ulCompression   = BCA_UNCOMP;
-    vHeader.cbImage         = nBytePerLine * nHeight;
-    vHeader.cclrUsed        = 0;
-
-    //
-    // These seem not really needed for our purpose here.
-    //
-    vHeader.cxResolution    = 0;
-    vHeader.cyResolution    = 0;
-    vHeader.cclrImportant   = 0;
-    vHeader.usUnits         = BRU_METRIC;
-    vHeader.usReserved      = 0;
-    vHeader.cSize1          = 0;
-    vHeader.cSize2          = 0;
-    vHeader.usRecording     = BRA_BOTTOMUP;
-    vHeader.usRendering     = BRH_NOTHALFTONED;
-    vHeader.ulColorEncoding = BCE_RGB;
-    vHeader.ulIdentifier    = 0;
 
     //
     // Memory for DIB data
     //
     unsigned char*                  pucBits;
 
 
     //
     // Memory for DIB data
     //
     unsigned char*                  pucBits;
 
-    pucBits = (unsigned char *)malloc(vHeader.cbImage);
+    pucBits = (unsigned char *)malloc(nBytePerLine * nHeight);
     if(!pucBits)
     {
         wxFAIL_MSG(wxT("could not allocate memory for DIB"));
         return FALSE;
     }
     if(!pucBits)
     {
         wxFAIL_MSG(wxT("could not allocate memory for DIB"));
         return FALSE;
     }
+    memset(pucBits, '\0', (nBytePerLine * nHeight));
 
     //
     // Create and set the device-dependent bitmap
 
     //
     // Create and set the device-dependent bitmap
@@ -618,16 +600,25 @@ bool wxBitmap::CreateFromImage (
     SIZEL                           vSize = {0, 0};
     HDC                             hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
     SIZEL                           vSize = {0, 0};
     HDC                             hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
+    LONG                            lScans;
+    HDC                             hDCScreen = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+    HPS                             hPSScreen;
     HBITMAP                         hBmp;
     HBITMAP                         hBmpOld;
 
     HBITMAP                         hBmp;
     HBITMAP                         hBmpOld;
 
+    memset(&vInfo, '\0', 16);
+    vInfo.cbFix           = 16;
+    vInfo.cx              = (ULONG)nWidth;
+    vInfo.cy              = (ULONG)nHeight;
+    vInfo.cPlanes         = 1;
+    vInfo.cBitCount       = 24; // Set to desired count going in
+
     hBmp = ::GpiCreateBitmap( hPS
                              ,&vHeader
                              ,0L
                              ,NULL
                              ,NULL
                             );
     hBmp = ::GpiCreateBitmap( hPS
                              ,&vHeader
                              ,0L
                              ,NULL
                              ,NULL
                             );
-    hBmpOld = ::GpiSetBitmap(hPS, hBmp);
 #if wxUSE_PALETTE
     HPAL                            hOldPalette = NULLHANDLE;
     if (rImage.GetPalette().Ok())
 #if wxUSE_PALETTE
     HPAL                            hOldPalette = NULLHANDLE;
     if (rImage.GetPalette().Ok())
@@ -647,6 +638,14 @@ bool wxBitmap::CreateFromImage (
     unsigned char*                  ptdata = pData;
     unsigned char*                  ptbits;
 
     unsigned char*                  ptdata = pData;
     unsigned char*                  ptbits;
 
+    if ((hBmpOld = ::GpiSetBitmap(hPS, hBmp)) == HBM_ERROR)
+    {
+        ERRORID                 vError;
+        wxString                sError;
+
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+    }
     for (n = 0; n < nNumDIB; n++)
     {
         if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
     for (n = 0; n < nNumDIB; n++)
     {
         if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
@@ -675,19 +674,41 @@ bool wxBitmap::CreateFromImage (
 
         //
         // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
 
         //
         // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
+        // in combination with setting the bits into the selected bitmap
         //
         //
-        POINTL                      vPoint[4] = { 0, nOrigin,
-                                                  nWidth, nHeight,
-                                                  0, 0, nWidth, nHeight
+        if ((lScans = ::GpiSetBitmapBits( hPS
+                                         ,0             // Start at the bottom
+                                         ,(LONG)nHeight // One line per scan
+                                         ,(PBYTE)pucBits
+                                         ,&vInfo
+                                       )) == GPI_ALTERROR)
+        {
+            ERRORID                 vError;
+            wxString                sError;
+
+            vError = ::WinGetLastError(vHabmain);
+            sError = wxPMErrorToStr(vError);
+        }
+        hPSScreen = ::GpiCreatePS( vHabmain
+                                  ,hDCScreen
+                                  ,&vSize
+                                  ,PU_PELS | GPIA_ASSOC
+                                 );
+
+        POINTL                      vPoint[4] = { {0, nOrigin},
+                                                  {nWidth, nHeight},
+                                                  {0, 0}, {nWidth, nHeight}
                                                 };
 
                                                 };
 
-        ::GpiBitBlt( hPS
+
+        ::GpiBitBlt( hPSScreen
                     ,hPS
                     ,4
                     ,vPoint
                     ,ROP_SRCCOPY
                     ,BBO_IGNORE
                    );
                     ,hPS
                     ,4
                     ,vPoint
                     ,ROP_SRCCOPY
                     ,BBO_IGNORE
                    );
+        ::GpiDestroyPS(hPSScreen);
         nOrigin += nHeight;
     }
     SetHBITMAP((WXHBITMAP)hBmp);
         nOrigin += nHeight;
     }
     SetHBITMAP((WXHBITMAP)hBmp);
@@ -701,12 +722,11 @@ bool wxBitmap::CreateFromImage (
     //
     if (rImage.HasMask())
     {
     //
     if (rImage.HasMask())
     {
-        memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
-        vHeader.cbFix     =  sizeof(BITMAPINFOHEADER2);
+        vHeader.cbFix     = 16;
         vHeader.cx        = nWidth;
         vHeader.cy        = nHeight;
         vHeader.cPlanes   = 1;
         vHeader.cx        = nWidth;
         vHeader.cy        = nHeight;
         vHeader.cPlanes   = 1;
-        vHeader.cBitCount = 1;
+        vHeader.cBitCount = 24;
         hBmp = ::GpiCreateBitmap( hPS
                                  ,&vHeader
                                  ,0L
         hBmp = ::GpiCreateBitmap( hPS
                                  ,&vHeader
                                  ,0L
@@ -719,7 +739,6 @@ bool wxBitmap::CreateFromImage (
         else
             nHeight = nSizeLimit / nBytePerLine;
         vHeader.cy = (DWORD)(nHeight);
         else
             nHeight = nSizeLimit / nBytePerLine;
         vHeader.cy = (DWORD)(nHeight);
-        vHeader.cbImage = nBytePerLine * nHeight;
         nOrigin = 0;
 
         unsigned char               cRed   = rImage.GetMaskRed();
         nOrigin = 0;
 
         unsigned char               cRed   = rImage.GetMaskRed();
@@ -746,7 +765,11 @@ bool wxBitmap::CreateFromImage (
             {
                 for (i = 0; i < nWidth; i++)
                 {
             {
                 for (i = 0; i < nWidth; i++)
                 {
-                    if ((*(ptdata++) != cRed) || (*(ptdata++) != cGreen) || (*(ptdata++) != cBlue))
+                    unsigned char cRedImage   = (*(ptdata++)) ;
+                    unsigned char cGreenImage = (*(ptdata++)) ;
+                    unsigned char cBlueImage  = (*(ptdata++)) ;
+
+                    if ((cRedImage != cRed) || (cGreenImage != cGreen) || (cBlueImage != cBlue))
                     {
                         *(ptbits++) = cOne;
                         *(ptbits++) = cOne;
                     {
                         *(ptbits++) = cOne;
                         *(ptbits++) = cOne;
@@ -762,18 +785,29 @@ bool wxBitmap::CreateFromImage (
                 for (i = 0; i < nPadding; i++)
                     *(ptbits++) = cZero;
             }
                 for (i = 0; i < nPadding; i++)
                     *(ptbits++) = cZero;
             }
-            POINTL                  vPoint[4] = { 0, nOrigin,
-                                                  nWidth, nHeight,
-                                                  0, 0, nWidth, nHeight
-                                                };
-
-            ::GpiBitBlt( hPS
+            lScans = ::GpiSetBitmapBits( hPS
+                                        ,0              // Start at the bottom
+                                        ,(LONG)nHeight // One line per scan
+                                        ,(PBYTE)pucBits
+                                        ,&vInfo
+                                       );
+            hPSScreen = ::GpiCreatePS( vHabmain
+                                      ,hDCScreen
+                                      ,&vSize
+                                      ,PU_PELS | GPIA_ASSOC
+                                     );
+            POINTL vPoint2[4] = { {0, nOrigin},
+                                  {nWidth, nHeight},
+                                  {0, 0}, {nWidth, nHeight}
+                                };
+            ::GpiBitBlt( hPSScreen
                         ,hPS
                         ,4
                         ,hPS
                         ,4
-                        ,vPoint
+                        ,vPoint2
                         ,ROP_SRCCOPY
                         ,BBO_IGNORE
                         ,ROP_SRCCOPY
                         ,BBO_IGNORE
-                       );
+                   );
+            ::GpiDestroyPS(hPSScreen);
             nOrigin += nHeight;
         }
 
             nOrigin += nHeight;
         }
 
@@ -784,7 +818,7 @@ bool wxBitmap::CreateFromImage (
 
         pMask->SetMaskBitmap((WXHBITMAP)hBmp);
         SetMask(pMask);
 
         pMask->SetMaskBitmap((WXHBITMAP)hBmp);
         SetMask(pMask);
-        hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+        hBmpOld = ::GpiSetBitmap(hPS, hBmpOld);
     }
 
     //
     }
 
     //
@@ -792,6 +826,7 @@ bool wxBitmap::CreateFromImage (
     //
     ::GpiSetBitmap(hPS, NULLHANDLE);
     ::GpiDestroyPS(hPS);
     //
     ::GpiSetBitmap(hPS, NULLHANDLE);
     ::GpiDestroyPS(hPS);
+    ::DevCloseDC(hDCScreen);
     ::DevCloseDC(hDC);
     free(pucBits);
     return TRUE;
     ::DevCloseDC(hDC);
     free(pucBits);
     return TRUE;
@@ -800,6 +835,7 @@ bool wxBitmap::CreateFromImage (
 wxImage wxBitmap::ConvertToImage() const
 {
     wxImage                         vImage;
 wxImage wxBitmap::ConvertToImage() const
 {
     wxImage                         vImage;
+    wxDC*                           pDC;
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
@@ -819,12 +855,12 @@ wxImage wxBitmap::ConvertToImage() const
     long                            lScans;
     BITMAPINFOHEADER2               vDIBh;
     BITMAPINFO2                     vDIBInfo;
     long                            lScans;
     BITMAPINFOHEADER2               vDIBh;
     BITMAPINFO2                     vDIBInfo;
-    HDC                             hDCMem;
-    PSZ                             pszData[4] = { "Display", NULL, NULL, NULL };
     HPS                             hPSMem;
     HPS                             hPSMem;
-    HPS                             hPS;
-    SIZEL                           vSizlPage = {0,0};
     HBITMAP                         hBitmap;
     HBITMAP                         hBitmap;
+    HBITMAP                         hOldBitmap;
+    DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    SIZEL                           vSizlPage = {0,0};
+    HDC                             hDCMem;
 
     vImage.Create( nWidth
                   ,nHeight
 
     vImage.Create( nWidth
                   ,nHeight
@@ -846,60 +882,77 @@ wxImage wxBitmap::ConvertToImage() const
     //
     // Create and fill a DIB header
     //
     //
     // Create and fill a DIB header
     //
-    memset(&vDIBh, '\0', sizeof(BITMAPINFOHEADER2));
-    vDIBh.cbFix     =  sizeof(BITMAPINFOHEADER2);
+    memset(&vDIBh, '\0', 16);
+    vDIBh.cbFix     =  16;
     vDIBh.cx        = nWidth;
     vDIBh.cy        = nHeight;
     vDIBh.cPlanes   = 1;
     vDIBh.cx        = nWidth;
     vDIBh.cy        = nHeight;
     vDIBh.cPlanes   = 1;
-    vDIBh.cbImage   = nBytePerLine * nHeight;
     vDIBh.cBitCount = 24;
 
     vDIBh.cBitCount = 24;
 
-    memset(&vDIBInfo, '\0', sizeof(BITMAPINFO2));
-    vDIBInfo.cbFix           = sizeof(BITMAPINFO2);
+    memset(&vDIBInfo, '\0', 16);
+    vDIBInfo.cbFix           = 16;
+    vDIBInfo.cx              = nWidth;
+    vDIBInfo.cy              = nHeight;
     vDIBInfo.cPlanes         = 1;
     vDIBInfo.cBitCount       = 24;
     vDIBInfo.cPlanes         = 1;
     vDIBInfo.cBitCount       = 24;
-    vDIBInfo.ulCompression   = BCA_UNCOMP;
-    vDIBInfo.usReserved      = 0;
-    vDIBInfo.usRecording     = BRA_BOTTOMUP;
-    vDIBInfo.usRendering     = BRH_NOTHALFTONED;
-    vDIBInfo.ulColorEncoding = BCE_RGB;
-    vDIBInfo.ulIdentifier    = 0;
-
-    lpBits = (unsigned char *)malloc(vDIBh.cbImage);
+
+    lpBits = (unsigned char *)malloc(nBytePerLine * nHeight);
     if (!lpBits)
     {
         wxFAIL_MSG(wxT("could not allocate data for DIB"));
         free(pData);
         return wxNullImage;
     }
     if (!lpBits)
     {
         wxFAIL_MSG(wxT("could not allocate data for DIB"));
         free(pData);
         return wxNullImage;
     }
+    memset(lpBits, '\0', (nBytePerLine * nHeight));
+    hBitmap = (HBITMAP)GetHBITMAP();
+
+    //
+    // May already be selected into a PS
+    //
+    if ((pDC = GetSelectedInto()) != NULL)
+    {
+        hPSMem = pDC->GetHPS();
+    }
+    else
+    {
+        hDCMem = ::DevOpenDC( vHabmain
+                             ,OD_MEMORY
+                             ,"*"
+                             ,5L
+                             ,(PDEVOPENDATA)&vDop
+                             ,NULLHANDLE
+                            );
+        hPSMem = ::GpiCreatePS( vHabmain
+                               ,hDCMem
+                               ,&vSizlPage
+                               ,PU_PELS | GPIA_ASSOC
+                              );
+    }
+    if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
+    {
+        ERRORID                 vError;
+        wxString                sError;
+
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+    }
 
     //
     // Copy data from the device-dependent bitmap to the DIB
     //
 
     //
     // Copy data from the device-dependent bitmap to the DIB
     //
-    hDCMem = ::DevOpenDC( vHabmain
-                         ,OD_MEMORY
-                         ,"*"
-                         ,4
-                         ,(PDEVOPENDATA)pszData
-                         ,NULLHANDLE
-                        );
-    hPSMem = ::GpiCreatePS( vHabmain
-                           ,hDCMem
-                           ,&vSizlPage
-                           ,PU_PELS | GPIA_ASSOC | GPIT_MICRO
-                          );
-    hBitmap = ::GpiCreateBitmap( hPSMem
-                                ,&vDIBh
-                                ,0L
-                                ,NULL
-                                ,NULL
-                               );
-    lScans = ::GpiQueryBitmapBits( hPSMem
-                                  ,0L
-                                  ,(LONG)nHeight
-                                  ,(PBYTE)lpBits
-                                  ,&vDIBInfo
-                                 );
+    if ((lScans = ::GpiQueryBitmapBits( hPSMem
+                                       ,0L
+                                       ,(LONG)nHeight
+                                       ,(PBYTE)lpBits
+                                       ,&vDIBInfo
+                                      )) == GPI_ALTERROR)
+    {
+        ERRORID                     vError;
+        wxString                    sError;
+
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+    }
 
     //
     // Copy DIB data into the wxImage object
 
     //
     // Copy DIB data into the wxImage object
@@ -920,6 +973,12 @@ wxImage wxBitmap::ConvertToImage() const
         }
         ptbits += nPadding;
     }
         }
         ptbits += nPadding;
     }
+    if ((pDC = GetSelectedInto()) == NULL)
+    {
+        ::GpiSetBitmap(hPSMem, NULLHANDLE);
+        ::GpiDestroyPS(hPSMem);
+        ::DevCloseDC(hDCMem);
+    }
 
     //
     // Similarly, set data according to the possible mask bitmap
 
     //
     // Similarly, set data according to the possible mask bitmap
@@ -931,26 +990,28 @@ wxImage wxBitmap::ConvertToImage() const
         //
         // Memory DC/PS created, color set, data copied, and memory DC/PS deleted
         //
         //
         // Memory DC/PS created, color set, data copied, and memory DC/PS deleted
         //
-        HDC                         hMemDC = ::DevOpenDC( vHabmain
-                                                         ,OD_MEMORY
-                                                         ,"*"
-                                                         ,4
-                                                         ,(PDEVOPENDATA)pszData
-                                                         ,NULLHANDLE
-                                                        );
+        HDC                        hMemDC = ::DevOpenDC( vHabmain
+                                                        ,OD_MEMORY
+                                                        ,"*"
+                                                        ,5L
+                                                        ,(PDEVOPENDATA)&vDop
+                                                        ,NULLHANDLE
+                                                       );
         HPS                         hMemPS = ::GpiCreatePS( vHabmain
                                                            ,hMemDC
                                                            ,&vSizlPage
         HPS                         hMemPS = ::GpiCreatePS( vHabmain
                                                            ,hMemDC
                                                            ,&vSizlPage
-                                                           ,PU_PELS | GPIA_ASSOC | GPIT_MICRO
+                                                           ,PU_PELS | GPIA_ASSOC
                                                           );
         ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0));
         ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) );
                                                           );
         ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0));
         ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) );
+        ::GpiSetBitmap(hMemPS, hBitmap);
         ::GpiQueryBitmapBits( hPSMem
                              ,0L
                              ,(LONG)nHeight
                              ,(PBYTE)lpBits
                              ,&vDIBInfo
                             );
         ::GpiQueryBitmapBits( hPSMem
                              ,0L
                              ,(LONG)nHeight
                              ,(PBYTE)lpBits
                              ,&vDIBInfo
                             );
+        ::GpiSetBitmap(hMemPS, NULLHANDLE);
         ::GpiDestroyPS(hMemPS);
         ::DevCloseDC(hMemDC);
 
         ::GpiDestroyPS(hMemPS);
         ::DevCloseDC(hMemDC);
 
@@ -993,8 +1054,6 @@ wxImage wxBitmap::ConvertToImage() const
     //
     // Free allocated resources
     //
     //
     // Free allocated resources
     //
-    ::GpiDestroyPS(hPSMem);
-    ::DevCloseDC(hDCMem);
     free(lpBits);
     return vImage;
 } // end of wxBitmap::ConvertToImage
     free(lpBits);
     return vImage;
 } // end of wxBitmap::ConvertToImage
@@ -1029,9 +1088,9 @@ wxBitmap wxBitmap::GetSubBitmap(
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
-    POINTL                          vPoint[4] = { rRect.x, rRect.y,
-                                                  rRect.x + rRect.width, rRect.y + rRect.height,
-                                                  0, 0, GetWidth(), GetHeight()
+    POINTL                          vPoint[4] = { {0, 0}, {rRect.width, rRect.height},
+                                                  {rRect.x, rRect.y},
+                                                  {rRect.x + rRect.width, rRect.y + rRect.height}
                                                 };
 
     ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
                                                 };
 
     ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
@@ -1056,7 +1115,7 @@ wxBitmap wxBitmap::GetSubBitmap(
         vBmih.cx        = rRect.width;
         vBmih.cy        = rRect.height;
         vBmih.cPlanes   = 1;
         vBmih.cx        = rRect.width;
         vBmih.cy        = rRect.height;
         vBmih.cPlanes   = 1;
-        vBmih.cBitCount = 1;
+        vBmih.cBitCount = 24;
 
         HBITMAP                     hBmpMask = ::GpiCreateBitmap( hPSDst
                                                                  ,&vBmih
 
         HBITMAP                     hBmpMask = ::GpiCreateBitmap( hPSDst
                                                                  ,&vBmih
@@ -1104,17 +1163,6 @@ void wxBitmap::SetQuality(
     GetBitmapData()->m_nQuality = nQ;
 } // end of wxBitmap::SetQuality
 
     GetBitmapData()->m_nQuality = nQ;
 } // end of wxBitmap::SetQuality
 
-#if WXWIN_COMPATIBILITY_2
-void wxBitmap::SetOk(
-  bool                              bOk
-)
-{
-    EnsureHasData();
-
-    GetBitmapData()->m_bOk = bOk;
-} // end of wxBitmap::SetOk
-#endif // WXWIN_COMPATIBILITY_2
-
 void wxBitmap::SetPalette(
   const wxPalette&                  rPalette
 )
 void wxBitmap::SetPalette(
   const wxPalette&                  rPalette
 )
@@ -1202,8 +1250,8 @@ bool wxMask::Create(
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
-    POINTL                          vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
-                                                  0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
+    POINTL                          vPoint[4] = { {0 ,0}, {rBitmap.GetWidth(), rBitmap.GetHeight()},
+                                                  {0, 0}, {rBitmap.GetWidth(), rBitmap.GetHeight()}
                                                 };
 
     if (m_hMaskBitmap)
                                                 };
 
     if (m_hMaskBitmap)
@@ -1221,7 +1269,7 @@ bool wxMask::Create(
     vBmih.cx        = rBitmap.GetWidth();
     vBmih.cy        = rBitmap.GetHeight();
     vBmih.cPlanes   = 1;
     vBmih.cx        = rBitmap.GetWidth();
     vBmih.cy        = rBitmap.GetHeight();
     vBmih.cPlanes   = 1;
-    vBmih.cBitCount = 1;
+    vBmih.cBitCount = 24;
 
     m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
                                       ,&vBmih
 
     m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
                                       ,&vBmih
@@ -1303,9 +1351,6 @@ bool wxMask::Create(
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
-    POINTL                          vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
-                                                  0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
-                                                };
 
     if (m_hMaskBitmap)
     {
 
     if (m_hMaskBitmap)
     {
@@ -1407,8 +1452,7 @@ bool wxBitmapHandler::Create(
 
 bool wxBitmapHandler::Load(
   wxGDIImage*                       pImage
 
 bool wxBitmapHandler::Load(
   wxGDIImage*                       pImage
-, const wxString&                   rName
-, HPS                               hPs
+, int                               nId
 , long                              lFlags
 , int                               nWidth
 , int                               nHeight
 , long                              lFlags
 , int                               nWidth
 , int                               nHeight
@@ -1419,8 +1463,7 @@ bool wxBitmapHandler::Load(
                                                            );
 
     return(pBitmap ? LoadFile( pBitmap
                                                            );
 
     return(pBitmap ? LoadFile( pBitmap
-                              ,rName
-                              ,hPs
+                              ,nId
                               ,lFlags
                               ,nWidth
                               ,nHeight
                               ,lFlags
                               ,nWidth
                               ,nHeight
@@ -1457,8 +1500,7 @@ bool wxBitmapHandler::Create(
 
 bool wxBitmapHandler::LoadFile(
   wxBitmap*                         WXUNUSED(pBitmap)
 
 bool wxBitmapHandler::LoadFile(
   wxBitmap*                         WXUNUSED(pBitmap)
-, const wxString&                   WXUNUSED(rName)
-, HPS                               WXUNUSED(hPs)
+, int                               WXUNUSED(nId)
 , long                              WXUNUSED(lType)
 , int                               WXUNUSED(nDesiredWidth)
 , int                               WXUNUSED(nDesiredHeight)
 , long                              WXUNUSED(lType)
 , int                               WXUNUSED(nDesiredWidth)
 , int                               WXUNUSED(nDesiredHeight)
@@ -1511,16 +1553,16 @@ HBITMAP wxInvertMask(
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
-    POINTL                          vPoint[4] = { 0 ,0, nWidth, nHeight,
-                                                  0, 0, nWidth, nHeight
+    POINTL                          vPoint[4] = { {0 ,0}, {nWidth, nHeight},
+                                                  {0, 0}, {nWidth, nHeight}
                                                 };
 
                                                 };
 
-    memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
-    vBmih.cbFix     =  sizeof(BITMAPINFOHEADER2);
+    memset(&vBmih, '\0', 16);
+    vBmih.cbFix     = 16;
     vBmih.cx        = nWidth;
     vBmih.cy        = nHeight;
     vBmih.cPlanes   = 1;
     vBmih.cx        = nWidth;
     vBmih.cy        = nHeight;
     vBmih.cPlanes   = 1;
-    vBmih.cBitCount = 1;
+    vBmih.cBitCount = 24;
 
     hBmpInvMask = ::GpiCreateBitmap( hPSDst
                                     ,&vBmih
 
     hBmpInvMask = ::GpiCreateBitmap( hPSDst
                                     ,&vBmih
wxWidgets (Impactor)