No changes, just rebaked and reran autoconf.

[wxWidgets.git] / src / os2 / bitmap.cpp

diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp
index 872a468db57706a04851cb2bcf9349caf138fd1d..f8ae3d715d8b208576bcb35f47ac2ddec5581d27 100644 (file)
--- a/src/os2/bitmap.cpp
+++ b/src/os2/bitmap.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        bitmap.cpp
+// Name:        src/os2/bitmap.cpp

 // Purpose:     wxBitmap
 // Author:      David Webster
 // Modified by:
 // Purpose:     wxBitmap
 // Author:      David Webster
 // Modified by:


@@ -12,6 +12,8 @@
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

+#include "wx/bitmap.h"
+

 #ifndef WX_PRECOMP
     #include <stdio.h>
 
 #ifndef WX_PRECOMP
     #include <stdio.h>
 


@@ -20,26 +22,24 @@
     #include "wx/app.h"
     #include "wx/palette.h"
     #include "wx/dcmemory.h"
     #include "wx/app.h"
     #include "wx/palette.h"
     #include "wx/dcmemory.h"

-    #include "wx/bitmap.h"

     #include "wx/icon.h"
     #include "wx/icon.h"

+    #include "wx/log.h"
+    #include "wx/image.h"

 #endif
 
 #endif
 

+#include "wx/os2/dc.h"

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

-#include "wx/log.h"

 
 

-//#include "wx/msw/dib.h"
-#include "wx/image.h"
+#include "wx/xpmdecod.h"

 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARIES

 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 
 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 
 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)

-#endif

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


@@ -55,60 +55,90 @@ wxBitmapRefData::wxBitmapRefData()
     m_pSelectedInto = NULL;
     m_nNumColors    = 0;
     m_pBitmapMask   = NULL;
     m_pSelectedInto = NULL;
     m_nNumColors    = 0;
     m_pBitmapMask   = NULL;

+    m_hBitmap       = (WXHBITMAP) NULL;
+} // end of wxBitmapRefData::wxBitmapRefData
+
+wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData &tocopy)
+{
+    m_nQuality = tocopy.m_nQuality;
+    m_pSelectedInto = NULL;     // don't copy this
+    m_nNumColors    = tocopy.m_nNumColors;
+
+    // copy the mask
+    if (tocopy.m_pBitmapMask)
+        m_pBitmapMask = new wxMask(*tocopy.m_pBitmapMask);
+
+    m_hBitmap = wxCopyBmp(tocopy.m_hBitmap);

 }
 
 void wxBitmapRefData::Free()
 {
 }
 
 void wxBitmapRefData::Free()
 {

-    wxASSERT_MSG( !m_pSelectedInto,
-                  wxT("deleting bitmap still selected into wxMemoryDC") );
-
+    if ( m_pSelectedInto )
+    {
+        wxLogLastError(wxT("GpiDeleteBitmap(hbitmap)"));
+    }

     if (m_hBitmap)
     {
     if (m_hBitmap)
     {

-        if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
+        if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))

         {
         {

-            wxLogLastError("GpiDeleteBitmap(hbitmap)");
+            wxLogLastError(wxT("GpiDeleteBitmap(hbitmap)"));

         }
     }
         }
     }

-
-    delete m_pBitmapMask;
-    m_pBitmapMask = NULL;
-}
+    if (m_pBitmapMask)
+    {
+        delete m_pBitmapMask;
+        m_pBitmapMask = NULL;
+    }
+} // end of wxBitmapRefData::Free

 
 // ----------------------------------------------------------------------------
 // wxBitmap creation
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxBitmap creation
 // ----------------------------------------------------------------------------
 

+wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
+{
+    return new wxBitmapRefData(*static_cast<const wxBitmapRefData *>(data));
+}
+

 // 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_refData = NULL; done in the base class ctor
-
-    if (wxTheBitmapList)
-        wxTheBitmapList->AddBitmap(this);
-}
+    m_bIsMono = false;
+    //
+    // True for all bitmaps created from bits, wxImages, Xpms
+    //
+} // end of wxBitmap::Init

 
 

-bool wxBitmap::CopyFromIconOrCursor(
-  const wxGDIImage&                 rIcon
-)
+bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& rIcon)

 {
 {

+    HPOINTER                        hIcon = (HPOINTER)rIcon.GetHandle();
+    POINTERINFO                     SIconInfo;
+
+    if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
+    {
+        wxLogLastError(wxT("WinQueryPointerInfo"));
+        return false;
+    }

     wxBitmapRefData*                pRefData = new wxBitmapRefData;
 
     m_refData = pRefData;
 
     wxBitmapRefData*                pRefData = new wxBitmapRefData;
 
     m_refData = pRefData;
 

-    refData->m_width = rIcon.GetWidth();
-    refData->m_height = rIcon.GetHeight();
-    refData->m_depth = wxDisplayDepth();
+    int                             nWidth = rIcon.GetWidth();
+    int                             nHeight = rIcon.GetHeight();

 
 

-    refData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle();
-    // no mask???
-    refData->m_bitmapMask = new wxMask();
+    pRefData->m_nWidth  = nWidth;
+    pRefData->m_nHeight = nHeight;
+    pRefData->m_nDepth  = wxDisplayDepth();

 
 

-#if WXWIN_COMPATIBILITY_2
-    refData->m_ok = TRUE;
-#endif // WXWIN_COMPATIBILITY_2
+    pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;

 
 

-    return(TRUE);
-}
+    wxMask*                         pMask = new wxMask(SIconInfo.hbmPointer);
+
+    pMask->SetMaskBitmap(GetHBITMAP());
+    SetMask(pMask);
+
+    return true;
+} // end of wxBitmap::CopyFromIconOrCursor

 
 bool wxBitmap::CopyFromCursor(
   const wxCursor&                   rCursor
 
 bool wxBitmap::CopyFromCursor(
   const wxCursor&                   rCursor


@@ -117,9 +147,9 @@ bool wxBitmap::CopyFromCursor(
     UnRef();
 
     if (!rCursor.Ok())
     UnRef();
 
     if (!rCursor.Ok())

-        return(FALSE);
-    return CopyFromIconOrCursor(wxGDIImage)rCursor);
-}
+        return(false);
+    return(CopyFromIconOrCursor(rCursor));
+} // end of wxBitmap::CopyFromCursor

 
 bool wxBitmap::CopyFromIcon(
   const wxIcon&                     rIcon
 
 bool wxBitmap::CopyFromIcon(
   const wxIcon&                     rIcon


@@ -128,26 +158,20 @@ bool wxBitmap::CopyFromIcon(
     UnRef();
 
     if (!rIcon.Ok())
     UnRef();
 
     if (!rIcon.Ok())

-        return(FALSE);
+        return(false);

 
 

-#if WXWIN_COMPATIBILITY_2
-    refData->m_ok = TRUE;
-#endif // WXWIN_COMPATIBILITY_2
-
-    return CopyFromIconOrCursor(icon);
-}
+    return CopyFromIconOrCursor(rIcon);
+} // end of wxBitmap::CopyFromIcon

 
 wxBitmap::~wxBitmap()
 {
 
 wxBitmap::~wxBitmap()
 {

-    if (wxTheBitmapList)
-        wxTheBitmapList->DeleteObject(this);
-}
+} // end of wxBitmap::~wxBitmap

 
 wxBitmap::wxBitmap(
   const char                        zBits[]
 
 wxBitmap::wxBitmap(
   const char                        zBits[]

-, int                               nTheWidth
-, int                               nTheHeight
-, int                               nNoBits
+, int                               nWidth
+, int                               nHeight
+, int                               nDepth

 )
 {
     Init();
 )
 {
     Init();


@@ -157,85 +181,104 @@ wxBitmap::wxBitmap(
     BITMAPINFO2                     vInfo;
     HDC                             hDc;
     HPS                             hPs;
     BITMAPINFO2                     vInfo;
     HDC                             hDc;
     HPS                             hPs;

-    DEVOPENSTRUCT                   vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+    DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };

     SIZEL                           vSize = {0, 0};
     SIZEL                           vSize = {0, 0};

+    char*                           pzData;

 
 

-    wxAssert(vHabmain != NULL);
-
-    hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
-
-    vHeader.cbFix           = sizeof(vHeader);
-    vHeader.cx              = (USHORT)nTheWidth;
-    vHeader.cy              = (USHORT)nTheHeight;
-    vHeader.cPlanes         = 1L;
-    vHeader.cBitCount       = nNoBits;
-    vHeader.ulCompression   = BCA_UNCOMP;
-    vHeader.cxResolution    = 0;
-    vHeader.cyResolution    = 0;
-    vHeader.cclrUsed        = 0;
-    vHeader.cclrImportant   = 0;
-    vHeader.usUnits         = BRU_METRIC;
-    vHeader.usRecording     = BRA_BOTTOMUP;
-    vHeader.usRendering     = BRH_NOTHALFTONED;
-    vHeader.cSize1          = 0;
-    vHeader.cSize2          = 0;
-    vHeader.ulColorEncoding = 0;
-    vHeader.ulIdentifier    = 0;
-
-    vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
-    if (vhPs == 0)
-    {
-        wxLogLastError("GpiCreatePS Failure");
-    }
+    wxASSERT(vHabmain != NULL);

 
     m_refData = pRefData;
 
 
     m_refData = pRefData;
 

-    refData->m_width = nTheWidth;
-    refData->m_height = nTheHeight;
-    refData->m_depth = nNoBits;
-    refData->m_numColors = 0;
-    refData->m_selectedInto = NULL;
+    pRefData->m_nWidth        = nWidth;
+    pRefData->m_nHeight       = nHeight;
+    pRefData->m_nDepth        = nDepth;
+    pRefData->m_nNumColors    = 0;
+    pRefData->m_pSelectedInto = NULL;

 
 

-    HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
-    if ( !hbmp )
+    hDc   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+    hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
+    if (hPs == 0)

     {
     {

-        wxLogLastError("CreateBitmap");
+        wxLogLastError(wxT("GpiCreatePS Failure"));

     }
     }

-    SetHBITMAP((WXHBITMAP)hbmp);
-}

 
 

-// Create from XPM data
-wxBitmap::wxBitmap(
-  char**                            ppData
-, wxControl*                        WXUNUSED(pAnItem))
-{
-    Init();
+    if (nDepth == 1)
+    {
+        //
+        // We assume that it is in XBM format which is not quite the same as
+        // the format CreateBitmap() wants because the order of bytes in the
+        // line is reversed!
+        //
+        const size_t                nBytesPerLine = (nWidth + 7) / 8;
+        const size_t                nPadding = nBytesPerLine % 2;
+        const size_t                nLen = nHeight * (nPadding + nBytesPerLine);
+        const char*                 pzSrc = zBits;
+        int                         nRows;
+        size_t                      nCols;
+
+        pzData = (char *)malloc(nLen);
+
+        char*                       pzDst = pzData;
+
+        for (nRows = 0; nRows < nHeight; nRows++)
+        {
+            for (nCols = 0; nCols < nBytesPerLine; nCols++)
+            {
+                unsigned char ucVal = *pzSrc++;
+                unsigned char ucReversed = 0;
+                int nBits;
+
+                for (nBits = 0; nBits < 8; nBits++)
+                {
+                    ucReversed <<= 1;
+                    ucReversed = (unsigned char)(ucReversed | (ucVal & 0x01));
+                    ucVal >>= 1;
+                }
+                *pzDst++ = ucReversed;
+            }
+            if (nPadding)
+                *pzDst++ = 0;
+        }
+    }
+    else
+    {
+        //
+        // Bits should already be in Windows standard format
+        //
+        pzData = (char *)zBits;    // const_cast is harmless
+    }

 
 

-F    (void)Create( (void *)ppData
-                 ,wxBITMAP_TYPE_XPM_DATA
-                 ,0
-                 ,0
-                 ,0
-                );
-}
+    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       = (USHORT)nDepth;
+    vHeader.usReserved      = 0;

 
 

-wxBitmap::wxBitmap(
-  int                               nW
-, int                               nH
-, int                               nD
-)
-{
-    Init();
+    memset(&vInfo, '\0', 16);
+    vInfo.cbFix           = 16;
+    vInfo.cx              = (USHORT)nWidth;
+    vInfo.cy              = (USHORT)nHeight;
+    vInfo.cPlanes         = 1L;
+    vInfo.cBitCount       = (USHORT)nDepth;

 
 

-    (void)Create( nW
-                 ,nH
-                 ,nD
-                );
-}
+    HBITMAP                         hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
+
+    if (!hBmp)
+    {
+        wxLogLastError(wxT("CreateBitmap"));
+    }
+    ::GpiDestroyPS(hPs);
+    ::DevCloseDC(hDc);
+    SetHBITMAP((WXHBITMAP)hBmp);
+} // end of wxBitmap::wxBitmap

 
 wxBitmap::wxBitmap(
 
 wxBitmap::wxBitmap(

-  void*                             pData
-, long                              lType
+  const void*                       pData
+, wxBitmapType                      lType

 , int                               nWidth
 , int                               nHeight
 , int                               nDepth
 , int                               nWidth
 , int                               nHeight
 , int                               nDepth


@@ -249,19 +292,19 @@ wxBitmap::wxBitmap(
                  ,nHeight
                  ,nDepth
                 );
                  ,nHeight
                  ,nDepth
                 );

-}
+} // end of wxBitmap::wxBitmap

 
 wxBitmap::wxBitmap(
 
 wxBitmap::wxBitmap(

-  const wxString&                   rFilename
-, long                              lType
+  int                               nId
+, wxBitmapType                      lType

 )
 {
     Init();
 )
 {
     Init();

-
-    LoadFile( rFilename
-             ,(int)lType
+    LoadFile( nId
+             ,lType

             );
             );

-}
+    SetId(nId);
+} // end of wxBitmap::wxBitmap

 
 bool wxBitmap::Create(
   int                               nW
 
 bool wxBitmap::Create(
   int                               nW


@@ -271,78 +314,79 @@ bool wxBitmap::Create(
 {
     HBITMAP                         hBmp;
     BITMAPINFOHEADER2               vHeader;
 {
     HBITMAP                         hBmp;
     BITMAPINFOHEADER2               vHeader;

-    BITMAPINFO2                     vInfo;
-    HDC                             hDc;
-    HPS                             hPs;
-    DEVOPENSTRUCT                   vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
-    SIZEL                           vSize = {0, 0};
-
-    wxAssert(vHabmain != NULL);
-
-    hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
-
-    vHeader.cbFix           = sizeof(vHeader);
-    vHeader.cx              = (USHORT)nW;
-    vHeader.cy              = (USHORT)nH;
-    vHeader.cPlanes         = (USHORT)nD;
-    vHeader.cBitCount       = 24;
-    vHeader.ulCompression   = BCA_UNCOMP;
-    vHeader.cxResolution    = 0;
-    vHeader.cyResolution    = 0;
-    vHeader.cclrUsed        = 0;
-    vHeader.cclrImportant   = 0;
-    vHeader.usUnits         = BRU_METRIC;
-    vHeader.usRecording     = BRA_BOTTOMUP;
-    vHeader.usRendering     = BRH_NOTHALFTONED;
-    vHeader.cSize1          = 0;
-    vHeader.cSize2          = 0;
-    vHeader.ulColorEncoding = 0;
-    vHeader.ulIdentifier    = 0;
-
-    vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
-    if (vhPs == 0)
-    {
-        wxLogLastError("GpiCreatePS Failure");
-    }
-

 
 

+    wxASSERT(vHabmain != NULL);

     UnRef();
     m_refData = new wxBitmapRefData;
     UnRef();
     m_refData = new wxBitmapRefData;

-
-    GetBitmapData()->m_width = nW;
-    GetBitmapData()->m_height = nH;
-    GetBitmapData()->m_depth = nD;
-
+    GetBitmapData()->m_nWidth = nW;
+    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)
     {
     if (nD > 0)
     {

-        hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
-        if (!hBmp)
-        {
-            wxLogLastError("CreateBitmap");
-        }
+        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);
+
+        if (nD == 1)
+            m_bIsMono = true;
+        memset(&vHeader, '\0', 16);
+        vHeader.cbFix     =  16;
+        vHeader.cx        = nW;
+        vHeader.cy        = nH;
+        vHeader.cPlanes   = 1;
+        vHeader.cBitCount = 24; //nD;
+
+        hBmp = ::GpiCreateBitmap( hPS
+                                 ,&vHeader
+                                 ,0L
+                                 ,NULL
+                                 ,NULL
+                                );
+        ::GpiDestroyPS(hPS);
+        ::DevCloseDC(hDC);

     }
     else
     {
     }
     else
     {

-        ScreenHDC dc;
-        hbmp = ::CreateCompatibleBitmap(dc, w, h);
-        if ( !hbmp )
-        {
-            wxLogLastError("CreateCompatibleBitmap");
-        }
-
-        GetBitmapData()->m_depth = wxDisplayDepth();
+        HPS                             hPSScreen;
+        HDC                             hDCScreen;
+        LONG                            lBitCount;
+
+        hPSScreen = ::WinGetScreenPS(HWND_DESKTOP);
+        hDCScreen = ::GpiQueryDevice(hPSScreen);
+        ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
+
+        if (lBitCount > 24)
+            lBitCount = 24;
+
+        memset(&vHeader, '\0', 16);
+        vHeader.cbFix     =  16;
+        vHeader.cx        = nW;
+        vHeader.cy        = nH;
+        vHeader.cPlanes   = 1;
+        vHeader.cBitCount = (USHORT)lBitCount;
+
+        hBmp = ::GpiCreateBitmap( hPSScreen
+                                 ,&vHeader
+                                 ,0L
+                                 ,NULL
+                                 ,NULL
+                                );
+
+        GetBitmapData()->m_nDepth = wxDisplayDepth();
+        ::WinReleasePS(hPSScreen);

     }
     }

-
-    SetHBITMAP((WXHBITMAP)hbmp);
-
-#if WXWIN_COMPATIBILITY_2
-    GetBitmapData()->m_ok = hbmp != 0;
-#endif // WXWIN_COMPATIBILITY_2
+    SetHBITMAP((WXHBITMAP)hBmp);

 
     return Ok();
 
     return Ok();

-}
+} // end of wxBitmap::Create

 
 

-bool wxBitmap::LoadFile(const wxString& filename, long type)
+bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)

 {
     UnRef();
 
 {
     UnRef();
 


@@ -354,141 +398,803 @@ bool wxBitmap::LoadFile(const wxString& filename, long type)
 
         return handler->LoadFile(this, filename, type, -1, -1);
     }
 
         return handler->LoadFile(this, filename, type, -1, -1);
     }

-    else
+#if wxUSE_IMAGE
+    else // no bitmap handler found

     {
         wxImage image;
     {
         wxImage image;

-        if ( !image.LoadFile( filename, type ) || !image.Ok() )
-            return FALSE;
-
-        *this = image.ConvertToBitmap();
+        if ( image.LoadFile( filename, type ) && image.Ok() )
+        {
+            *this = wxBitmap(image);

 
 

-        return TRUE;
+            return true;
+        }

     }
     }

+#endif // wxUSE_IMAGE
+
+    return false;

 }
 
 }
 

-bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
+bool wxBitmap::LoadFile(
+  int                               nId
+, wxBitmapType                      lType
+)

 {
     UnRef();
 
 {
     UnRef();
 

-    wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
+    wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
+                                                             ,wxBitmapHandler
+                                                            );

 
 

-    if ( !handler )
+    if (pHandler)

     {
     {

-        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
-                       "type %d defined."), type);
+        m_refData = new wxBitmapRefData;

 
 

-        return FALSE;
+        return(pHandler->LoadFile( this
+                                  ,nId
+                                  ,lType
+                                  , -1
+                                  , -1
+                                 ));
+    }
+    else
+    {
+        return false;
+    }
+} // end of wxBitmap::LoadFile
+
+bool wxBitmap::Create(
+  const void*                       pData
+, wxBitmapType                      lType
+, int                               nWidth
+, int                               nHeight
+, int                               nDepth
+)
+{
+    UnRef();
+
+    wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
+                                                             ,wxBitmapHandler
+                                                            );
+
+    if (!pHandler)
+    {
+        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), lType);
+
+        return false;

     }
 
     m_refData = new wxBitmapRefData;
 
     }
 
     m_refData = new wxBitmapRefData;
 

-    return handler->Create(this, data, type, width, height, depth);
-}
+    return(pHandler->Create( this
+                            ,pData
+                            ,lType
+                            ,nWidth
+                            ,nHeight
+                            ,nDepth
+                           ));
+} // end of wxBitmap::Create

 
 

-bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
+bool wxBitmap::SaveFile(
+  const wxString&                   rFilename
+, wxBitmapType                      lType
+, const wxPalette*                  pPalette
+)

 {
 {

-    wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
+    wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
+                                                             ,wxBitmapHandler
+                                                            );

 
 

-    if ( handler )
+    if (pHandler)

     {
     {

-        return handler->SaveFile(this, filename, type, palette);
+        return pHandler->SaveFile( this
+                                  ,rFilename
+                                  ,lType
+                                  ,pPalette
+                                 );

     }
     else
     {
         // FIXME what about palette? shouldn't we use it?
     }
     else
     {
         // FIXME what about palette? shouldn't we use it?

-        wxImage image( *this );
-        if (!image.Ok())
-            return FALSE;
+        wxImage                     vImage = ConvertToImage();

 
 

-        return image.SaveFile( filename, type );
+        if (!vImage.Ok())
+            return false;
+
+        return(vImage.SaveFile( rFilename
+                               ,lType
+                              ));

     }
     }

-}
+} // end of wxBitmap::SaveFile
+

 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------

-// wxBitmap accessors
+// wxImage-wxBitmap conversion

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-void wxBitmap::SetQuality(int q)
+bool wxBitmap::CreateFromImage (
+  const wxImage&                    rImage
+, int                               nDepth
+)

 {
 {

-    EnsureHasData();
+    wxCHECK_MSG(rImage.Ok(), false, wxT("invalid image"));
+    m_refData = new wxBitmapRefData();
+
+    int                             nSizeLimit = 1024 * 768 * 3;
+    int                             nWidth = rImage.GetWidth();
+    int                             nBmpHeight = rImage.GetHeight();
+    int                             nBytePerLine = nWidth * 3;
+    int                             nSizeDWORD = sizeof(DWORD);
+    int                             nLineBoundary = nBytePerLine % nSizeDWORD;
+    int                             nPadding = 0;
+
+    if (nLineBoundary > 0)
+    {
+        nPadding = nSizeDWORD - nLineBoundary;
+        nBytePerLine += nPadding;
+    }

 
 

-    GetBitmapData()->m_quality = q;
-}
+    //
+    // Calc the number of DIBs and heights of DIBs
+    //
+    int                             nNumDIB = 1;
+    int                             nHRemain = 0;
+    int                             nHeight = nSizeLimit / nBytePerLine;

 
 

-#if WXWIN_COMPATIBILITY_2
-void wxBitmap::SetOk(bool isOk)
-{
-    EnsureHasData();
+    if (nHeight >= nBmpHeight)
+        nHeight = nBmpHeight;
+    else
+    {
+        nNumDIB  = nBmpHeight / nHeight;
+        nHRemain = nBmpHeight % nHeight;
+        if (nHRemain > 0)
+            nNumDIB++;
+    }

 
 

-    GetBitmapData()->m_ok = isOk;
-}
-#endif // WXWIN_COMPATIBILITY_2
+    //
+    // Set bitmap parameters
+    //
+    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 wxUSE_PALETTE
+    //
+    // Copy the palette from the source image
+    //
+    SetPalette(rImage.GetPalette());
+#endif // wxUSE_PALETTE
+
+    //
+    // Create a DIB header
+    //
+    BITMAPINFOHEADER2               vHeader;
+    BITMAPINFO2                     vInfo;

 
 

-void wxBitmap::SetPalette(const wxPalette& palette)
-{
-    EnsureHasData();
+    //
+    // Fill in the DIB header
+    //
+    memset(&vHeader, '\0', 16);
+    vHeader.cbFix           = 16;
+    vHeader.cx              = (ULONG)nWidth;
+    vHeader.cy              = (ULONG)nHeight;
+    vHeader.cPlanes         = 1L;
+    vHeader.cBitCount       = 24;

 
 

-    GetBitmapData()->m_bitmapPalette = palette;
-}
+    //
+    // Memory for DIB data
+    //
+    unsigned char*                  pucBits;

 
 

-void wxBitmap::SetMask(wxMask *mask)
-{
-    EnsureHasData();
+    pucBits = (unsigned char *)malloc(nBytePerLine * nHeight);
+    if(!pucBits)
+    {
+        wxFAIL_MSG(wxT("could not allocate memory for DIB"));
+        return false;
+    }
+    memset(pucBits, '\0', (nBytePerLine * nHeight));

 
 

-    GetBitmapData()->m_bitmapMask = mask;
-}
+    //
+    // Create and set the device-dependent bitmap
+    //
+    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);
+    LONG                            lScans;
+    HDC                             hDCScreen = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+    HPS                             hPSScreen;
+    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
+                            );
+#if wxUSE_PALETTE
+    HPAL                            hOldPalette = NULLHANDLE;
+    if (rImage.GetPalette().Ok())
+    {
+        hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE());
+    }
+#endif // wxUSE_PALETTE
+
+    //
+    // Copy image data into DIB data and then into DDB (in a loop)
+    //
+    unsigned char*                  pData = rImage.GetData();
+    int                             i;
+    int                             j;
+    int                             n;
+    int                             nOrigin = 0;
+    unsigned char*                  ptdata = pData;
+    unsigned char*                  ptbits;
+
+    if ((hBmpOld = ::GpiSetBitmap(hPS, hBmp)) == HBM_ERROR)
+    {
+        ERRORID                 vError;
+        wxString                sError;

 
 

-// Creates a bitmap that matches the device context, from
-// an arbitray bitmap. At present, the original bitmap must have an
-// associated palette. TODO: use a default palette if no palette exists.
-// Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
-wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
-{
-    wxMemoryDC      memDC;
-    wxBitmap        tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
-    HPALETTE        hPal = (HPALETTE) NULL;
-    LPBITMAPINFO    lpDib;
-    void            *lpBits = (void*) NULL;
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+    }
+    for (n = 0; n < nNumDIB; n++)
+    {
+        if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
+        {
+            //
+            // Redefine height and size of the (possibly) last smaller DIB
+            // memory is not reallocated
+            //
+            nHeight         = nHRemain;
+            vHeader.cy      = (DWORD)(nHeight);
+            vHeader.cbImage = nBytePerLine * nHeight;
+        }
+        ptbits = pucBits;
+        for (j = 0; j < nHeight; j++)
+        {
+            for (i = 0; i < nWidth; i++)
+            {
+                *(ptbits++) = *(ptdata + 2);
+                *(ptbits++) = *(ptdata + 1);
+                *(ptbits++) = *(ptdata);
+                ptdata += 3;
+            }
+            for (i = 0; i < nPadding; i++)
+                *(ptbits++) = 0;
+        }
+
+        //
+        // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
+        // in combination with setting the bits into the selected bitmap
+        //
+        if ((lScans = ::GpiSetBitmapBits( hPS
+                                         ,0             // Start at the bottom
+                                         ,(LONG)nHeight // One line per scan
+                                         ,(PBYTE)pucBits
+                                         ,&vInfo
+                                       )) == GPI_ALTERROR)
+        {
+            ERRORID                 vError;
+            wxString                sError;

 
 

-    if( GetPalette() && GetPalette()->Ok() )
+            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( hPSScreen
+                    ,hPS
+                    ,4
+                    ,vPoint
+                    ,ROP_SRCCOPY
+                    ,BBO_IGNORE
+                   );
+        ::GpiDestroyPS(hPSScreen);
+        nOrigin += nHeight;
+    }
+    SetHBITMAP((WXHBITMAP)hBmp);
+#if wxUSE_PALETTE
+    if (hOldPalette)
+        ::GpiSelectPalette(hPS, hOldPalette);
+#endif // wxUSE_PALETTE
+
+    //
+    // Similarly, created an mono-bitmap for the possible mask
+    //
+    if (rImage.HasMask())
+    {
+        vHeader.cbFix     = 16;
+        vHeader.cx        = nWidth;
+        vHeader.cy        = nHeight;
+        vHeader.cPlanes   = 1;
+        vHeader.cBitCount = 24;
+        hBmp = ::GpiCreateBitmap( hPS
+                                 ,&vHeader
+                                 ,0L
+                                 ,NULL
+                                 ,NULL
+                                );
+        hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+        if (nNumDIB == 1)
+            nHeight = nBmpHeight;
+        else
+            nHeight = nSizeLimit / nBytePerLine;
+        vHeader.cy = (DWORD)(nHeight);
+        nOrigin = 0;
+
+        unsigned char               cRed   = rImage.GetMaskRed();
+        unsigned char               cGreen = rImage.GetMaskGreen();
+        unsigned char               cBlue  = rImage.GetMaskBlue();
+        unsigned char               cZero = 0;
+        unsigned char               cOne = 255;
+
+        ptdata = pData;
+        for (n = 0; n < nNumDIB; n++)
+        {
+            if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
+            {
+                //
+                // Redefine height and size of the (possibly) last smaller DIB
+                // memory is not reallocated
+                //
+                nHeight         = nHRemain;
+                vHeader.cy      = (DWORD)(nHeight);
+                vHeader.cbImage = nBytePerLine * nHeight;
+            }
+            ptbits = pucBits;
+            for (int j = 0; j < nHeight; j++)
+            {
+                for (i = 0; i < nWidth; i++)
+                {
+                    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;
+                    }
+                    else
+                    {
+                        *(ptbits++) = cZero;
+                        *(ptbits++) = cZero;
+                        *(ptbits++) = cZero;
+                    }
+                }
+                for (i = 0; i < nPadding; i++)
+                    *(ptbits++) = cZero;
+            }
+            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
+                        ,vPoint2
+                        ,ROP_SRCCOPY
+                        ,BBO_IGNORE
+                   );
+            ::GpiDestroyPS(hPSScreen);
+            nOrigin += nHeight;
+        }
+
+        //
+        // Create a wxMask object
+        //
+        wxMask*                     pMask = new wxMask();
+
+        pMask->SetMaskBitmap((WXHBITMAP)hBmp);
+        SetMask(pMask);
+        hBmpOld = ::GpiSetBitmap(hPS, hBmpOld);
+    }
+
+    //
+    // Free allocated resources
+    //
+    ::GpiSetBitmap(hPS, NULLHANDLE);
+    ::GpiDestroyPS(hPS);
+    ::DevCloseDC(hDCScreen);
+    ::DevCloseDC(hDC);
+    free(pucBits);
+    return true;
+} // end of wxBitmap::CreateFromImage
+
+wxImage wxBitmap::ConvertToImage() const
+{
+    wxImage                         vImage;
+    wxDC*                           pDC;
+
+    wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+
+    //
+    // Create an wxImage object
+    //
+    int                             nWidth        = GetWidth();
+    int                             nHeight       = GetHeight();
+    int                             nDevWidth;
+    int                             nDevHeight;
+    int                             nBytePerLine  = nWidth * 3;
+    int                             nSizeDWORD    = sizeof(DWORD);
+    int                             nLineBoundary = nBytePerLine % nSizeDWORD;
+    int                             nPadding = 0;
+    unsigned char*                  pData;
+    unsigned char*                  lpBits;
+    long                            lScans;
+    BITMAPINFOHEADER2               vDIBh;
+    BITMAPINFO2                     vDIBInfo;
+    HPS                             hPSMem;
+    HBITMAP                         hBitmap;
+    HBITMAP                         hOldBitmap;
+    DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    SIZEL                           vSizlPage = {0,0};
+    HDC                             hDCMem = NULLHANDLE;
+
+    vImage.Create( nWidth
+                  ,nHeight
+                 );
+    pData = vImage.GetData();
+    if(!pData)

     {
     {

-        tmpBitmap.SetPalette(*GetPalette());
-        memDC.SelectObject(tmpBitmap);
-        memDC.SetPalette(*GetPalette());
-        hPal = (HPALETTE)GetPalette()->GetHPALETTE();
+        wxFAIL_MSG( wxT("could not allocate data for image") );
+        return wxNullImage;
+    }
+    if(nLineBoundary > 0)
+    {
+        nPadding     = nSizeDWORD - nLineBoundary;
+        nBytePerLine += nPadding;
+    }
+    wxDisplaySize( &nDevWidth
+                  ,&nDevHeight
+                 );
+    //
+    // Create and fill a DIB header
+    //
+    memset(&vDIBh, '\0', 16);
+    vDIBh.cbFix     =  16;
+    vDIBh.cx        = nWidth;
+    vDIBh.cy        = nHeight;
+    vDIBh.cPlanes   = 1;
+    vDIBh.cBitCount = 24;
+
+    memset(&vDIBInfo, '\0', 16);
+    vDIBInfo.cbFix           = 16;
+    vDIBInfo.cx              = nWidth;
+    vDIBInfo.cy              = nHeight;
+    vDIBInfo.cPlanes         = 1;
+    vDIBInfo.cBitCount       = 24;
+
+    lpBits = (unsigned char *)malloc(nBytePerLine * nHeight);
+    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
+    //
+    pDC = GetSelectedInto();
+    const wxPMDCImpl *impl;
+    if (pDC != NULL &&
+        (impl = wxDynamicCast( pDC->GetImpl(), wxPMDCImpl )) != NULL)
+    {
+        hPSMem = impl->GetHPS();

     }
     else
     {
     }
     else
     {

-        hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
-        wxPalette palette;
-        palette.SetHPALETTE( (WXHPALETTE)hPal );
-        tmpBitmap.SetPalette( palette );
-        memDC.SelectObject(tmpBitmap);
-        memDC.SetPalette( palette );
+        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;

 
 

-    // set the height negative because in a DIB the order of the lines is
-    // reversed
-    if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+    }
+
+    //
+    // Copy data from the device-dependent bitmap to the DIB
+    //
+    if ((lScans = ::GpiQueryBitmapBits( hPSMem
+                                       ,0L
+                                       ,(LONG)nHeight
+                                       ,(PBYTE)lpBits
+                                       ,&vDIBInfo
+                                      )) == GPI_ALTERROR)

     {
     {

-        return wxNullBitmap;
+        ERRORID                     vError;
+        wxString                    sError;
+
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);

     }
 
     }
 

-    lpBits = malloc(lpDib->bmiHeader.biSizeImage);
+    //
+    // Copy DIB data into the wxImage object
+    //
+    int                             i;
+    int                             j;
+    unsigned char*                  ptdata = pData;
+    unsigned char*                  ptbits = lpBits;

 
 

-    ::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits);
+    for (i = 0; i < nHeight; i++)
+    {
+        for (j = 0; j < nWidth; j++)
+        {
+            *(ptdata++) = *(ptbits+2);
+            *(ptdata++) = *(ptbits+1);
+            *(ptdata++) = *(ptbits  );
+            ptbits += 3;
+        }
+        ptbits += nPadding;
+    }
+    if ((pDC = GetSelectedInto()) == NULL)
+    {
+        ::GpiSetBitmap(hPSMem, NULLHANDLE);
+        ::GpiDestroyPS(hPSMem);
+        ::DevCloseDC(hDCMem);
+    }

 
 

-    ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
-                        GetWidth(), GetHeight(),
-                        0, 0, 0, GetHeight(),
-                        lpBits, lpDib, DIB_RGB_COLORS);
+    //
+    // Similarly, set data according to the possible mask bitmap
+    //
+    if (GetMask() && GetMask()->GetMaskBitmap())
+    {
+        hBitmap = (HBITMAP)GetMask()->GetMaskBitmap();
+
+        //
+        // Memory DC/PS created, color set, data copied, and memory DC/PS deleted
+        //
+        HDC                        hMemDC = ::DevOpenDC( vHabmain
+                                                        ,OD_MEMORY
+                                                        ,"*"
+                                                        ,5L
+                                                        ,(PDEVOPENDATA)&vDop
+                                                        ,NULLHANDLE
+                                                       );
+        HPS                         hMemPS = ::GpiCreatePS( vHabmain
+                                                           ,hMemDC
+                                                           ,&vSizlPage
+                                                           ,PU_PELS | GPIA_ASSOC
+                                                          );
+        ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0));
+        ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) );
+        ::GpiSetBitmap(hMemPS, hBitmap);
+        ::GpiQueryBitmapBits( hPSMem
+                             ,0L
+                             ,(LONG)nHeight
+                             ,(PBYTE)lpBits
+                             ,&vDIBInfo
+                            );
+        ::GpiSetBitmap(hMemPS, NULLHANDLE);
+        ::GpiDestroyPS(hMemPS);
+        ::DevCloseDC(hMemDC);
+
+        //
+        // Background color set to RGB(16,16,16) in consistent with wxGTK
+        //
+        unsigned char               ucRed = 16;
+        unsigned char               ucGreen = 16;
+        unsigned char               ucBlue = 16;
+
+        ptdata = pData;
+        ptbits = lpBits;
+        for (i = 0; i < nHeight; i++)
+        {
+            for (j = 0; j < nWidth; j++)
+            {
+                if (*ptbits != 0)
+                    ptdata += 3;
+                else
+                {
+                    *(ptdata++)  = ucRed;
+                    *(ptdata++)  = ucGreen;
+                    *(ptdata++)  = ucBlue;
+                }
+                ptbits += 3;
+            }
+            ptbits += nPadding;
+        }
+        vImage.SetMaskColour( ucRed
+                             ,ucGreen
+                             ,ucBlue
+                            );
+        vImage.SetMask(true);
+    }
+    else
+    {
+        vImage.SetMask(false);
+    }

 
 

+    //
+    // Free allocated resources
+    //

     free(lpBits);
     free(lpBits);

+    return vImage;
+} // end of wxBitmap::ConvertToImage

 
 

-    wxFreeDIB(lpDib);
+// ----------------------------------------------------------------------------
+// sub bitmap extraction
+// ----------------------------------------------------------------------------

 
 

-    return tmpBitmap;
-}
+wxBitmap wxBitmap::GetSubBitmap(
+  const wxRect&                     rRect
+) const
+{
+    wxCHECK_MSG( Ok() &&
+                 (rRect.x >= 0) && (rRect.y >= 0) &&
+                 (rRect.x + rRect.width <= GetWidth()) &&
+                 (rRect.y + rRect.height <= GetHeight()),
+                 wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
+
+    wxBitmap                        vRet( rRect.width
+                                         ,rRect.height
+                                         ,GetDepth()
+                                        );
+    wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") );
+
+
+    //
+    // Copy bitmap data
+    //
+    SIZEL                           vSize = {0, 0};
+    DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+    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}, {rRect.width, rRect.height},
+                                                  {rRect.x, rRect.y},
+                                                  {rRect.x + rRect.width, rRect.y + rRect.height}
+                                                };
+
+    ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
+    ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
+    ::GpiBitBlt( hPSDst
+                ,hPSSrc
+                ,4L
+                ,vPoint
+                ,ROP_SRCCOPY
+                ,BBO_IGNORE
+               );
+
+    //
+    // Copy mask if there is one
+    //
+    if (GetMask())
+    {
+        BITMAPINFOHEADER2           vBmih;
+
+        memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
+        vBmih.cbFix     = sizeof(BITMAPINFOHEADER2);
+        vBmih.cx        = rRect.width;
+        vBmih.cy        = rRect.height;
+        vBmih.cPlanes   = 1;
+        vBmih.cBitCount = 24;
+
+        HBITMAP                     hBmpMask = ::GpiCreateBitmap( hPSDst
+                                                                 ,&vBmih
+                                                                 ,0L
+                                                                 ,NULL
+                                                                 ,NULL
+                                                                );
+
+        ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
+        ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
+
+        ::GpiSetBitmap(hPSSrc, (HBITMAP) GetMask()->GetMaskBitmap());
+        ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpMask);
+        ::GpiBitBlt( hPSDst
+                    ,hPSSrc
+                    ,4L
+                    ,vPoint
+                    ,ROP_SRCCOPY
+                    ,BBO_IGNORE
+                   );
+
+        wxMask*                     pMask = new wxMask((WXHBITMAP)hBmpMask);
+        vRet.SetMask(pMask);
+    }
+
+    ::GpiSetBitmap(hPSSrc, NULL);
+    ::GpiSetBitmap(hPSDst, NULL);
+    ::GpiDestroyPS(hPSSrc);
+    ::GpiDestroyPS(hPSDst);
+    ::DevCloseDC(hDCSrc);
+    ::DevCloseDC(hDCDst);
+    return vRet;
+} // end of wxBitmap::GetSubBitmap
+
+// ----------------------------------------------------------------------------
+// wxBitmap accessors
+// ----------------------------------------------------------------------------
+
+void wxBitmap::SetQuality(
+  int                               nQ
+)
+{
+    EnsureHasData();
+
+    GetBitmapData()->m_nQuality = nQ;
+} // end of wxBitmap::SetQuality
+
+void wxBitmap::SetPalette(
+  const wxPalette&                  rPalette
+)
+{
+    EnsureHasData();
+
+    GetBitmapData()->m_vBitmapPalette = rPalette;
+} // end of wxBitmap::SetPalette
+
+void wxBitmap::SetMask(
+  wxMask*                           pMask
+)
+{
+    EnsureHasData();
+
+    GetBitmapData()->m_pBitmapMask = pMask;
+} // end of wxBitmap::SetMask
+
+wxBitmap wxBitmap::GetBitmapForDC(wxDC& WXUNUSED(rDc)) const
+{
+    return(*this);
+} // end of wxBitmap::GetBitmapForDC

 
 // ----------------------------------------------------------------------------
 // wxMask
 
 // ----------------------------------------------------------------------------
 // wxMask


@@ -496,250 +1202,494 @@ wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
 
 wxMask::wxMask()
 {
 
 wxMask::wxMask()
 {

-    m_maskBitmap = 0;
-}
+    m_hMaskBitmap = 0;
+} // end of wxMask::wxMask
+
+wxMask::wxMask(const wxMask& tocopy)
+{
+    m_hMaskBitmap = wxCopyBmp(tocopy.m_hMaskBitmap);
+} // end of wxMask::wxMask

 
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area

-wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
+wxMask::wxMask(
+  const wxBitmap&                   rBitmap
+, const wxColour&                   rColour
+)

 {
 {

-    m_maskBitmap = 0;
-    Create(bitmap, colour);
-}
+    m_hMaskBitmap = 0;
+    Create( rBitmap
+           ,rColour
+          );
+} // end of wxMask::wxMask

 
 // Construct a mask from a bitmap and a palette index indicating
 // the transparent area
 
 // Construct a mask from a bitmap and a palette index indicating
 // the transparent area

-wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
+wxMask::wxMask(
+  const wxBitmap&                   rBitmap
+, int                               nPaletteIndex
+)

 {
 {

-    m_maskBitmap = 0;
-    Create(bitmap, paletteIndex);
-}
+    m_hMaskBitmap = 0;
+    Create( rBitmap
+           ,nPaletteIndex
+          );
+} // end of wxMask::wxMask

 
 // Construct a mask from a mono bitmap (copies the bitmap).
 
 // Construct a mask from a mono bitmap (copies the bitmap).

-wxMask::wxMask(const wxBitmap& bitmap)
+wxMask::wxMask(
+  const wxBitmap&                   rBitmap
+)

 {
 {

-    m_maskBitmap = 0;
-    Create(bitmap);
-}
+    m_hMaskBitmap = 0;
+    Create(rBitmap);
+} // end of wxMask::wxMask

 
 wxMask::~wxMask()
 {
 
 wxMask::~wxMask()
 {

-    if ( m_maskBitmap )
-        ::DeleteObject((HBITMAP) m_maskBitmap);
-}
+    if (m_hMaskBitmap)
+        ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
+} // end of wxMask::~wxMask

 
 // Create a mask from a mono bitmap (copies the bitmap).
 
 // Create a mask from a mono bitmap (copies the bitmap).

-bool wxMask::Create(const wxBitmap& bitmap)
-{
-    if ( m_maskBitmap )
-    {
-        ::DeleteObject((HBITMAP) m_maskBitmap);
-        m_maskBitmap = 0;
-    }
-    if (!bitmap.Ok() || bitmap.GetDepth() != 1)
-    {
-        return FALSE;
-    }
-    m_maskBitmap = (WXHBITMAP) CreateBitmap(
-                                            bitmap.GetWidth(),
-                                            bitmap.GetHeight(),
-                                            1, 1, 0
-                                           );
-    HDC srcDC = CreateCompatibleDC(0);
-    SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
-    HDC destDC = CreateCompatibleDC(0);
-    SelectObject(destDC, (HBITMAP) m_maskBitmap);
-    BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
-    SelectObject(srcDC, 0);
-    DeleteDC(srcDC);
-    SelectObject(destDC, 0);
-    DeleteDC(destDC);
-    return TRUE;
-}
+bool wxMask::Create(
+  const wxBitmap&                   rBitmap
+)
+{
+    BITMAPINFOHEADER2               vBmih;
+    SIZEL                           vSize = {0, 0};
+    DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+    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)
+    {
+        ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
+        m_hMaskBitmap = 0;
+    }
+    if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
+    {
+        return false;
+    }
+
+    memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
+    vBmih.cbFix     =  sizeof(BITMAPINFOHEADER2);
+    vBmih.cx        = rBitmap.GetWidth();
+    vBmih.cy        = rBitmap.GetHeight();
+    vBmih.cPlanes   = 1;
+    vBmih.cBitCount = 24;
+
+    m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
+                                      ,&vBmih
+                                      ,0L
+                                      ,NULL
+                                      ,NULL
+                                     );
+
+    ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
+    ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
+    ::GpiBitBlt( hPSDst
+                ,hPSSrc
+                ,4L
+                ,vPoint
+                ,ROP_SRCCOPY
+                ,BBO_IGNORE
+               );
+
+    ::GpiDestroyPS(hPSSrc);
+    ::GpiDestroyPS(hPSDst);
+    ::DevCloseDC(hDCSrc);
+    ::DevCloseDC(hDCDst);
+    return true;
+} // end of wxMask::Create

 
 // Create a mask from a bitmap and a palette index indicating
 // the transparent area
 
 // Create a mask from a bitmap and a palette index indicating
 // the transparent area

-bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
+bool wxMask::Create(
+  const wxBitmap&                   rBitmap
+, int                               nPaletteIndex
+)

 {
 {

-    if ( m_maskBitmap )
+    if (m_hMaskBitmap)

     {
     {

-        ::DeleteObject((HBITMAP) m_maskBitmap);
-        m_maskBitmap = 0;
+        ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
+        m_hMaskBitmap = 0;

     }
     }

-    if (bitmap.Ok() && bitmap.GetPalette()->Ok())
+    if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())

     {
     {

-        unsigned char red, green, blue;
-        if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
+        unsigned char               cRed;
+        unsigned char               cGreen;
+        unsigned char               cBlue;
+
+        if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
+                                         ,&cRed
+                                         ,&cGreen
+                                         ,&cBlue
+                                        ))

         {
         {

-            wxColour transparentColour(red, green, blue);
-            return Create(bitmap, transparentColour);
+            wxColour                vTransparentColour( cRed
+                                                       ,cGreen
+                                                       ,cBlue
+                                                      );
+
+            return (Create( rBitmap
+                           ,vTransparentColour
+                          ));

         }
     }
         }
     }

-    return FALSE;
-}
+    return false;
+} // end of wxMask::Create

 
 // Create a mask from a bitmap and a colour indicating
 // the transparent area
 
 // Create a mask from a bitmap and a colour indicating
 // the transparent area

-bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
+bool wxMask::Create(
+  const wxBitmap&                   rBitmap
+, const wxColour&                   rColour
+)

 {
 {

-    if ( m_maskBitmap )
+    bool                            bOk = true;
+    COLORREF                        vMaskColour = OS2RGB( rColour.Red()
+                                                         ,rColour.Green()
+                                                         ,rColour.Blue()
+                                                        );
+    BITMAPINFOHEADER2               vBmih;
+    SIZEL                           vSize = {0, 0};
+    DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+    HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+    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);
+
+    if (m_hMaskBitmap)

     {
     {

-        ::DeleteObject((HBITMAP) m_maskBitmap);
-        m_maskBitmap = 0;
+        ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
+        m_hMaskBitmap = 0;

     }
     }

-    if (!bitmap.Ok())
+    if (!rBitmap.Ok())

     {
     {

-        return FALSE;
+        return false;

     }
 
     }
 

-    // scan the bitmap for the transparent colour and set
+    //
+    // Scan the bitmap for the transparent colour and set

     // the corresponding pixels in the mask to BLACK and
     // the rest to WHITE
     // the corresponding pixels in the mask to BLACK and
     // the rest to WHITE

-    COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue());
-    m_maskBitmap = (WXHBITMAP) ::CreateBitmap(
-            bitmap.GetWidth(),
-            bitmap.GetHeight(),
-            1, 1, 0
-                                             );
-    HDC srcDC = ::CreateCompatibleDC(0);
-    ::SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
-    HDC destDC = ::CreateCompatibleDC(0);
-    ::SelectObject(destDC, (HBITMAP) m_maskBitmap);
-
-    // this is not very efficient, but I can't think
+    //
+
+    memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
+    vBmih.cbFix     =  sizeof(BITMAPINFOHEADER2);
+    vBmih.cx        = rBitmap.GetWidth();
+    vBmih.cy        = rBitmap.GetHeight();
+    vBmih.cPlanes   = 1;
+    vBmih.cBitCount = 1;
+
+    m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
+                                      ,&vBmih
+                                      ,0L
+                                      ,NULL
+                                      ,NULL
+                                     );
+
+    ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
+    ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
+
+    //
+    // This is not very efficient, but I can't think

     // of a better way of doing it
     // of a better way of doing it

-    for (int w = 0; w < bitmap.GetWidth(); w++)
+    //
+    for (int w = 0; w < rBitmap.GetWidth(); w++)

     {
     {

-        for (int h = 0; h < bitmap.GetHeight(); h++)
+        for (int h = 0; h < rBitmap.GetHeight(); h++)

         {
         {

-            COLORREF col = GetPixel(srcDC, w, h);
-            if (col == maskColour)
+            POINTL                  vPt = {w, h};
+            COLORREF                vCol = (COLORREF)::GpiQueryPel(hPSSrc, &vPt);
+            if (vCol == (COLORREF)CLR_NOINDEX)

             {
             {

-                ::SetPixel(destDC, w, h, RGB(0, 0, 0));
+                //
+                // Doesn't make sense to continue
+                //
+                bOk = false;
+                break;
+            }
+
+            if (vCol == vMaskColour)
+            {
+                ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0));
+                ::GpiSetPel(hPSDst, &vPt);

             }
             else
             {
             }
             else
             {

-                ::SetPixel(destDC, w, h, RGB(255, 255, 255));
+                ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255));
+                ::GpiSetPel(hPSDst, &vPt);

             }
         }
     }
             }
         }
     }

-    ::SelectObject(srcDC, 0);
-    ::DeleteDC(srcDC);
-    ::SelectObject(destDC, 0);
-    ::DeleteDC(destDC);
-    return TRUE;
-}
+    ::GpiSetBitmap(hPSSrc, NULL);
+    ::GpiSetBitmap(hPSDst, NULL);
+    ::GpiDestroyPS(hPSSrc);
+    ::GpiDestroyPS(hPSDst);
+    ::DevCloseDC(hDCSrc);
+    ::DevCloseDC(hDCDst);
+    return true;
+} // end of wxMask::Create

 
 // ----------------------------------------------------------------------------
 // wxBitmapHandler
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxBitmapHandler
 // ----------------------------------------------------------------------------
 

-bool wxBitmapHandler::Create(wxGDIImage *image,
-                             void *data,
-                             long flags,
-                             int width, int height, int depth)
+bool wxBitmapHandler::Create( wxGDIImage* pImage,
+                              const void* pData,
+                              wxBitmapType lType,
+                              int         nWidth,
+                              int         nHeight,
+                              int         nDepth)

 {
 {

-    wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
-
-    return bitmap ? Create(bitmap, data, width, height, depth) : FALSE;
+    wxBitmap* pBitmap = wxDynamicCast( pImage
+                                      ,wxBitmap
+                                       );
+
+    return(pBitmap ? Create( pBitmap
+                            ,pData
+                            ,lType
+                            ,nWidth
+                            ,nHeight
+                            ,nDepth
+                           ) : false);

 }
 
 }
 

-bool wxBitmapHandler::Load(wxGDIImage *image,
-                           const wxString& name,
-                           long flags,
-                           int width, int height)
+bool wxBitmapHandler::Load(
+  wxGDIImage*                       pImage
+, int                               nId
+, wxBitmapType                      lFlags
+, int                               nWidth
+, int                               nHeight
+)

 {
 {

-    wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
-
-    return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE;
+    wxBitmap*                       pBitmap = wxDynamicCast( pImage
+                                                            ,wxBitmap
+                                                           );
+
+    return(pBitmap ? LoadFile( pBitmap
+                              ,nId
+                              ,lFlags
+                              ,nWidth
+                              ,nHeight
+                             ) : false);

 }
 
 }
 

-bool wxBitmapHandler::Save(wxGDIImage *image,
-                           const wxString& name,
-                           int type)
+bool wxBitmapHandler::Save(
+  const wxGDIImage*                 pImage
+, const wxString&                   rName
+, wxBitmapType                      lType
+) const

 {
 {

-    wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
+    wxBitmap*                       pBitmap = wxDynamicCast( pImage
+                                                            ,wxBitmap
+                                                           );
+
+    return(pBitmap ? SaveFile( pBitmap
+                              ,rName
+                              ,lType
+                             ) : false);
+}

 
 

-    return bitmap ? SaveFile(bitmap, name, type) : FALSE;
+bool wxBitmapHandler::Create(
+  wxBitmap*                         WXUNUSED(pBitmap)
+, const void*                       WXUNUSED(pData)
+, wxBitmapType                      WXUNUSED(lType)
+, int                               WXUNUSED(nWidth)
+, int                               WXUNUSED(nHeight)
+, int                               WXUNUSED(nDepth)
+)
+{
+    return false;

 }
 
 }
 

-bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
-                             void *WXUNUSED(data),
-                             long WXUNUSED(type),
-                             int WXUNUSED(width),
-                             int WXUNUSED(height),
-                             int WXUNUSED(depth))
+bool wxBitmapHandler::LoadFile(
+  wxBitmap*                         WXUNUSED(pBitmap)
+, int                               WXUNUSED(nId)
+, wxBitmapType                      WXUNUSED(lType)
+, int                               WXUNUSED(nDesiredWidth)
+, int                               WXUNUSED(nDesiredHeight)
+)

 {
 {

-    return FALSE;
+    return false;

 }
 
 }
 

-bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
-                               const wxString& WXUNUSED(name),
-                               long WXUNUSED(type),
-                               int WXUNUSED(desiredWidth),
-                               int WXUNUSED(desiredHeight))
+bool wxBitmapHandler::LoadFile(
+  wxBitmap*                         WXUNUSED(pBitmap)
+, const wxString&                   WXUNUSED(rName)
+, wxBitmapType                      WXUNUSED(lType)
+, int                               WXUNUSED(nDesiredWidth)
+, int                               WXUNUSED(nDesiredHeight)
+)

 {
 {

-    return FALSE;
+    return false;

 }
 
 }
 

-bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
-                               const wxString& WXUNUSED(name),
-                               int WXUNUSED(type),
-                               const wxPalette *WXUNUSED(palette))
+bool wxBitmapHandler::SaveFile(
+  wxBitmap*                         WXUNUSED(pBitmap)
+, const wxString&                   WXUNUSED(rName)
+, wxBitmapType                      WXUNUSED(nType)
+, const wxPalette*                  WXUNUSED(pPalette)
+) const

 {
 {

-    return FALSE;
+    return false;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// DIB functions
+// Utility functions

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-
-bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
-                 HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
+HBITMAP wxInvertMask(
+  HBITMAP                           hBmpMask
+, int                               nWidth
+, int                               nHeight
+)

 {
 {

-   unsigned long   i, headerSize;
-   LPBITMAPINFO    lpDIBheader = NULL;
-   LPPALETTEENTRY  lpPe = NULL;
-
-
-   // Allocate space for a DIB header
-   headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
-   lpDIBheader = (BITMAPINFO *) malloc(headerSize);
-   lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
-
-   GetPaletteEntries(hPal, 0, 256, lpPe);
-
-   memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
+    HBITMAP                         hBmpInvMask = 0;

 
 

-   // Fill in the static parts of the DIB header
-   lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-   lpDIBheader->bmiHeader.biWidth = xSize;
-   lpDIBheader->bmiHeader.biHeight = ySize;
-   lpDIBheader->bmiHeader.biPlanes = 1;
+    wxCHECK_MSG( hBmpMask, 0, wxT("invalid bitmap in wxInvertMask") );

 
 

-   // this value must be 1, 4, 8 or 24 so PixelDepth can only be
-   lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
-   lpDIBheader->bmiHeader.biCompression = BI_RGB;
-   lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3;
-   lpDIBheader->bmiHeader.biClrUsed = 256;
-
-
-   // Initialize the DIB palette
-   for (i = 0; i < 256; i++) {
-      lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
-      lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
-      lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
-      lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
-   }
-
-   *lpDIBHeader = lpDIBheader;
+    //
+    // Get width/height from the bitmap if not given
+    //
+    if (!nWidth || !nHeight)
+    {
+        BITMAPINFOHEADER2           vBmhdr;

 
 

-   return TRUE;
-}
+        ::GpiQueryBitmapInfoHeader( hBmpMask
+                                   ,&vBmhdr
+                                  );
+        nWidth  = (int)vBmhdr.cx;
+        nHeight = (int)vBmhdr.cy;
+    }

 
 

-void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
+    BITMAPINFOHEADER2               vBmih;
+    SIZEL                           vSize = {0, 0};
+    DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+    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}
+                                                };
+
+    memset(&vBmih, '\0', 16);
+    vBmih.cbFix     = 16;
+    vBmih.cx        = nWidth;
+    vBmih.cy        = nHeight;
+    vBmih.cPlanes   = 1;
+    vBmih.cBitCount = 24;
+
+    hBmpInvMask = ::GpiCreateBitmap( hPSDst
+                                    ,&vBmih
+                                    ,0L
+                                    ,NULL
+                                    ,NULL
+                                   );
+
+    ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmpMask);
+    ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpInvMask);
+
+    ::GpiBitBlt( hPSDst
+                ,hPSSrc
+                ,4L
+                ,vPoint
+                ,ROP_SRCINVERT
+                ,BBO_IGNORE
+               );
+
+    ::GpiDestroyPS(hPSSrc);
+    ::GpiDestroyPS(hPSDst);
+    ::DevCloseDC(hDCSrc);
+    ::DevCloseDC(hDCDst);
+
+    return hBmpInvMask;
+} // end of WxWinGdi_InvertMask
+
+HBITMAP wxCopyBmp( HBITMAP hBmp, bool flip, int nWidth, int nHeight )

 {
 {

-    free(lpDIBHeader);
-}
+    wxCHECK_MSG( hBmp, 0, wxT("invalid bitmap in wxCopyBmp") );

 
 

+    //
+    // Get width/height from the bitmap if not given
+    //
+    if (!nWidth || !nHeight)
+    {
+        BITMAPINFOHEADER2 vBmhdr;

 
 

+        vBmhdr.cbFix  = 16;
+        ::GpiQueryBitmapInfoHeader( hBmp,
+                                    &vBmhdr );
+        nWidth        = (int)vBmhdr.cx;
+        nHeight       = (int)vBmhdr.cy;
+    }
+
+    BITMAPINFOHEADER2 vBmih;
+    SIZEL             vSize     = {0, 0};
+    DEVOPENSTRUC      vDop      = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    HDC               hDCSrc    = ::DevOpenDC(  vHabmain,
+                                                OD_MEMORY,
+                                                "*",
+                                                5L,
+                                                (PDEVOPENDATA)&vDop,
+                                                NULLHANDLE  );
+    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,      nHeight},
+                                    {nWidth, 0},
+                                    {0,      0},
+                                    {nWidth, nHeight} };
+    if (!flip)
+    {
+        vPoint[0].y = 0;
+        vPoint[1].y = nHeight;
+    }
+    memset(&vBmih, '\0', 16);
+    vBmih.cbFix     = 16;
+    vBmih.cx        = nWidth;
+    vBmih.cy        = nHeight;
+    vBmih.cPlanes   = 1;
+    vBmih.cBitCount = 24;
+
+    HBITMAP hInvBmp = ::GpiCreateBitmap(  hPSDst,
+                                          &vBmih,
+                                          0L,
+                                          NULL,
+                                          NULL  );
+
+    ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmp);
+    ::GpiSetBitmap(hPSDst, (HBITMAP) hInvBmp);
+
+    ::GpiBitBlt(  hPSDst,
+                  hPSSrc,
+                  4L,
+                  vPoint,
+                  ROP_SRCCOPY,
+                  BBO_IGNORE  );
+
+    ::GpiDestroyPS(hPSSrc);
+    ::GpiDestroyPS(hPSDst);
+    ::DevCloseDC(hDCSrc);
+    ::DevCloseDC(hDCDst);
+
+    return hInvBmp;
+} // end of wxFlipBmp