ignore mouse wheel events which are coming too fast to be processed (#9057)

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

diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp
index 6ea8aa4752793b3888f62fbe460ded4fd8ea3d62..bdd712eeee6921799d1cb6e1ccd1cc38b889cc31 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:


@@ -9,13 +9,11 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-    #pragma implementation "bitmap.h"
-#endif
-

 // 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>
 


@@ -24,15 +22,14 @@
     #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"
 
 // ----------------------------------------------------------------------------
 #include "wx/xpmdecod.h"
 
 // ----------------------------------------------------------------------------


@@ -58,39 +55,61 @@ 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
 
 } // 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()
 {
     if ( m_pSelectedInto )
     {
 void wxBitmapRefData::Free()
 {
     if ( m_pSelectedInto )
     {

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

     }
     if (m_hBitmap)
     {
         if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
         {
     }
     if (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
 // ----------------------------------------------------------------------------
 
 } // end of wxBitmapRefData::Free
 
 // ----------------------------------------------------------------------------
 // wxBitmap creation
 // ----------------------------------------------------------------------------
 

+wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
+{
+    return new wxBitmapRefData(*wx_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_bIsMono = false;
+    //
+    // True for all bitmaps created from bits, wxImages, Xpms
+    //

 } // end of wxBitmap::Init
 
 } // end of wxBitmap::Init
 

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

 {
     HPOINTER                        hIcon = (HPOINTER)rIcon.GetHandle();
     POINTERINFO                     SIconInfo;
 {
     HPOINTER                        hIcon = (HPOINTER)rIcon.GetHandle();
     POINTERINFO                     SIconInfo;


@@ -98,7 +117,7 @@ bool wxBitmap::CopyFromIconOrCursor(
     if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
     {
         wxLogLastError(wxT("WinQueryPointerInfo"));
     if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
     {
         wxLogLastError(wxT("WinQueryPointerInfo"));

-        return FALSE;
+        return false;

     }
     wxBitmapRefData*                pRefData = new wxBitmapRefData;
 
     }
     wxBitmapRefData*                pRefData = new wxBitmapRefData;
 


@@ -113,10 +132,12 @@ bool wxBitmap::CopyFromIconOrCursor(
 
     pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
 
 
     pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
 

-    //
-    // No mask in the Info struct in OS/2
-    //
-    return(TRUE);
+    wxMask*                         pMask = new wxMask(SIconInfo.hbmPointer);
+
+    pMask->SetMaskBitmap(GetHBITMAP());
+    SetMask(pMask);
+
+    return true;

 } // end of wxBitmap::CopyFromIconOrCursor
 
 bool wxBitmap::CopyFromCursor(
 } // end of wxBitmap::CopyFromIconOrCursor
 
 bool wxBitmap::CopyFromCursor(


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

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

     return(CopyFromIconOrCursor(rCursor));
 } // end of wxBitmap::CopyFromCursor
 
     return(CopyFromIconOrCursor(rCursor));
 } // end of wxBitmap::CopyFromCursor
 


@@ -137,7 +158,7 @@ bool wxBitmap::CopyFromIcon(
     UnRef();
 
     if (!rIcon.Ok())
     UnRef();
 
     if (!rIcon.Ok())

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

 
     return CopyFromIconOrCursor(rIcon);
 } // end of wxBitmap::CopyFromIcon
 
     return CopyFromIconOrCursor(rIcon);
 } // end of wxBitmap::CopyFromIcon


@@ -178,7 +199,7 @@ wxBitmap::wxBitmap(
     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
     if (hPs == 0)
     {
     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
     if (hPs == 0)
     {

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

     }
 
     if (nDepth == 1)
     }
 
     if (nDepth == 1)


@@ -186,7 +207,7 @@ wxBitmap::wxBitmap(
         //
         // 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
         //
         // 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 inversed!
+        // line is reversed!

         //
         const size_t                nBytesPerLine = (nWidth + 7) / 8;
         const size_t                nPadding = nBytesPerLine % 2;
         //
         const size_t                nBytesPerLine = (nWidth + 7) / 8;
         const size_t                nPadding = nBytesPerLine % 2;


@@ -203,14 +224,14 @@ wxBitmap::wxBitmap(
         {
             for (nCols = 0; nCols < nBytesPerLine; nCols++)
             {
         {
             for (nCols = 0; nCols < nBytesPerLine; nCols++)
             {

-                unsigned char       ucVal = *pzSrc++;
-                unsigned char       ucReversed = 0;
-                int                 nBits;
+                unsigned char ucVal = *pzSrc++;
+                unsigned char ucReversed = 0;
+                int nBits;

 
                 for (nBits = 0; nBits < 8; nBits++)
                 {
                     ucReversed <<= 1;
 
                 for (nBits = 0; nBits < 8; nBits++)
                 {
                     ucReversed <<= 1;

-                    ucReversed |= (ucVal & 0x01);
+                    ucReversed = (unsigned char)(ucReversed | (ucVal & 0x01));

                     ucVal >>= 1;
                 }
                 *pzDst++ = ucReversed;
                     ucVal >>= 1;
                 }
                 *pzDst++ = ucReversed;


@@ -227,12 +248,14 @@ wxBitmap::wxBitmap(
         pzData = (char *)zBits;    // const_cast is harmless
     }
 
         pzData = (char *)zBits;    // const_cast is harmless
     }
 

+    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;
     memset(&vHeader, '\0', 16);
     vHeader.cbFix           = 16;
     vHeader.cx              = (USHORT)nWidth;
     vHeader.cy              = (USHORT)nHeight;
     vHeader.cPlanes         = 1L;

-    vHeader.cBitCount       = nDepth;
+    vHeader.cBitCount       = (USHORT)nDepth;

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


@@ -240,13 +263,13 @@ wxBitmap::wxBitmap(
     vInfo.cx              = (USHORT)nWidth;
     vInfo.cy              = (USHORT)nHeight;
     vInfo.cPlanes         = 1L;
     vInfo.cx              = (USHORT)nWidth;
     vInfo.cy              = (USHORT)nHeight;
     vInfo.cPlanes         = 1L;

-    vInfo.cBitCount       = nDepth;
+    vInfo.cBitCount       = (USHORT)nDepth;

 
     HBITMAP                         hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
 
     if (!hBmp)
     {
 
     HBITMAP                         hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
 
     if (!hBmp)
     {

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

     }
     ::GpiDestroyPS(hPs);
     ::DevCloseDC(hDc);
     }
     ::GpiDestroyPS(hPs);
     ::DevCloseDC(hDc);


@@ -260,7 +283,6 @@ wxBitmap::wxBitmap(
 )
 {
     Init();
 )
 {
     Init();

-

     (void)Create( nW
                  ,nH
                  ,nD
     (void)Create( nW
                  ,nH
                  ,nD


@@ -268,8 +290,8 @@ wxBitmap::wxBitmap(
 } // end of wxBitmap::wxBitmap
 
 wxBitmap::wxBitmap(
 } // end of 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


@@ -286,15 +308,15 @@ wxBitmap::wxBitmap(
 } // end of wxBitmap::wxBitmap
 
 wxBitmap::wxBitmap(
 } // end of 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(
 } // end of wxBitmap::wxBitmap
 
 bool wxBitmap::Create(


@@ -313,6 +335,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};


@@ -320,12 +346,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);
 

+        if (nD == 1)
+            m_bIsMono = true;

         memset(&vHeader, '\0', 16);
         vHeader.cbFix     =  16;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;
         memset(&vHeader, '\0', 16);
         vHeader.cbFix     =  16;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;

-        vHeader.cBitCount = nD;
+        vHeader.cBitCount = 24; //nD;

 
         hBmp = ::GpiCreateBitmap( hPS
                                  ,&vHeader
 
         hBmp = ::GpiCreateBitmap( hPS
                                  ,&vHeader


@@ -346,12 +374,15 @@ bool wxBitmap::Create(
         hDCScreen = ::GpiQueryDevice(hPSScreen);
         ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 
         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;
         memset(&vHeader, '\0', 16);
         vHeader.cbFix     =  16;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;

-        vHeader.cBitCount = lBitCount;
+        vHeader.cBitCount = (USHORT)lBitCount;

 
         hBmp = ::GpiCreateBitmap( hPSScreen
                                  ,&vHeader
 
         hBmp = ::GpiCreateBitmap( hPSScreen
                                  ,&vHeader


@@ -365,41 +396,42 @@ 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
 

-bool wxBitmap::CreateFromXpm(
-  const char**                      ppData
-)
+bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)

 {
 {

-#if wxUSE_IMAGE && wxUSE_XPM
-    Init();
+    UnRef();

 
 

-    wxCHECK_MSG(ppData != NULL, FALSE, wxT("invalid bitmap data"))
+    wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);

 
 

-    wxXPMDecoder                    vDecoder;
-    wxImage                         vImg = vDecoder.ReadData(ppData);
+    if ( handler )
+    {
+        m_refData = new wxBitmapRefData;

 
 

-    wxCHECK_MSG(vImg.Ok(), FALSE, wxT("invalid bitmap data"))
+        return handler->LoadFile(this, filename, type, -1, -1);
+    }
+#if wxUSE_IMAGE
+    else // no bitmap handler found
+    {
+        wxImage image;
+        if ( image.LoadFile( filename, type ) && image.Ok() )
+        {
+            *this = wxBitmap(image);

 
 

-    *this = wxBitmap(vImg);
-    return TRUE;
-#else
-    return FALSE;
-#endif
-} // end of wxBitmap::CreateFromXpm
+            return true;
+        }
+    }
+#endif // wxUSE_IMAGE
+
+    return false;
+}

 
 bool wxBitmap::LoadFile(
 
 bool wxBitmap::LoadFile(

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

 )
 {
 )
 {

-    HPS                             hPs = NULLHANDLE;
-

     UnRef();
 
     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
     UnRef();
 
     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)


@@ -411,8 +443,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


@@ -420,20 +451,13 @@ 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
 
 bool wxBitmap::Create(
     }
 } // end of wxBitmap::LoadFile
 
 bool wxBitmap::Create(

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

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


@@ -447,10 +471,9 @@ 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;

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


@@ -466,7 +489,7 @@ bool wxBitmap::Create(
 
 bool wxBitmap::SaveFile(
   const wxString&                   rFilename
 
 bool wxBitmap::SaveFile(
   const wxString&                   rFilename

-, int                               lType
+, wxBitmapType                      lType

 , const wxPalette*                  pPalette
 )
 {
 , const wxPalette*                  pPalette
 )
 {


@@ -488,7 +511,7 @@ bool wxBitmap::SaveFile(
         wxImage                     vImage = ConvertToImage();
 
         if (!vImage.Ok())
         wxImage                     vImage = ConvertToImage();
 
         if (!vImage.Ok())

-            return(FALSE);
+            return false;

 
         return(vImage.SaveFile( rFilename
                                ,lType
 
         return(vImage.SaveFile( rFilename
                                ,lType


@@ -498,7 +521,7 @@ bool wxBitmap::SaveFile(
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------

-// wxImage-wxBitmap convertion
+// wxImage-wxBitmap conversion

 // ----------------------------------------------------------------------------
 
 bool wxBitmap::CreateFromImage (
 // ----------------------------------------------------------------------------
 
 bool wxBitmap::CreateFromImage (


@@ -506,10 +529,9 @@ bool wxBitmap::CreateFromImage (
 , int                               nDepth
 )
 {
 , int                               nDepth
 )
 {

-    wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+    wxCHECK_MSG(rImage.Ok(), false, wxT("invalid image"));

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

-

     int                             nSizeLimit = 1024 * 768 * 3;
     int                             nWidth = rImage.GetWidth();
     int                             nBmpHeight = rImage.GetHeight();
     int                             nSizeLimit = 1024 * 768 * 3;
     int                             nWidth = rImage.GetWidth();
     int                             nBmpHeight = rImage.GetHeight();


@@ -544,9 +566,13 @@ bool wxBitmap::CreateFromImage (
     //
     // Set bitmap parameters
     //
     //
     // Set bitmap parameters
     //

-    wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+    wxCHECK_MSG(rImage.Ok(), false, wxT("invalid image"));

     SetWidth(nWidth);
     SetHeight(nBmpHeight);
     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);


@@ -574,12 +600,6 @@ bool wxBitmap::CreateFromImage (
     vHeader.cPlanes         = 1L;
     vHeader.cBitCount       = 24;
 
     vHeader.cPlanes         = 1L;
     vHeader.cBitCount       = 24;
 

-    memset(&vInfo, '\0', 16);
-    vInfo.cbFix           = 16;
-    vInfo.cx              = (ULONG)nWidth;
-    vInfo.cy              = (ULONG)nHeight;
-    vInfo.cPlanes         = 1L;
-    vInfo.cBitCount       = 24;

     //
     // Memory for DIB data
     //
     //
     // Memory for DIB data
     //


@@ -589,8 +609,9 @@ bool wxBitmap::CreateFromImage (
     if(!pucBits)
     {
         wxFAIL_MSG(wxT("could not allocate memory for DIB"));
     if(!pucBits)
     {
         wxFAIL_MSG(wxT("could not allocate memory for DIB"));

-        return FALSE;
+        return false;

     }
     }

+    memset(pucBits, '\0', (nBytePerLine * nHeight));

 
     //
     // Create and set the device-dependent bitmap
 
     //
     // Create and set the device-dependent bitmap


@@ -600,18 +621,24 @@ bool wxBitmap::CreateFromImage (
     HDC                             hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
     LONG                            lScans;
     HDC                             hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
     LONG                            lScans;

-    HDC                             hDCScreen = ::WinOpenWindowDC(HWND_DESKTOP);
+    HDC                             hDCScreen = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);

     HPS                             hPSScreen;
     HBITMAP                         hBmp;
     HBITMAP                         hBmpOld;
 
     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
                             );
     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())


@@ -631,6 +658,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)


@@ -674,16 +709,15 @@ bool wxBitmap::CreateFromImage (
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
         }
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
         }

-

         hPSScreen = ::GpiCreatePS( vHabmain
                                   ,hDCScreen
                                   ,&vSize
                                   ,PU_PELS | GPIA_ASSOC
                                  );
 
         hPSScreen = ::GpiCreatePS( vHabmain
                                   ,hDCScreen
                                   ,&vSize
                                   ,PU_PELS | GPIA_ASSOC
                                  );
 

-        POINTL                      vPoint[4] = { 0, nOrigin,
-                                                  nWidth, nHeight,
-                                                  0, 0, nWidth, nHeight
+        POINTL                      vPoint[4] = { {0, nOrigin},
+                                                  {nWidth, nHeight},
+                                                  {0, 0}, {nWidth, nHeight}

                                                 };
 
 
                                                 };
 
 


@@ -708,11 +742,11 @@ bool wxBitmap::CreateFromImage (
     //
     if (rImage.HasMask())
     {
     //
     if (rImage.HasMask())
     {

-        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


@@ -725,7 +759,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();


@@ -752,7 +785,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;


@@ -779,9 +816,9 @@ bool wxBitmap::CreateFromImage (
                                       ,&vSize
                                       ,PU_PELS | GPIA_ASSOC
                                      );
                                       ,&vSize
                                       ,PU_PELS | GPIA_ASSOC
                                      );

-            POINTL vPoint2[4] = { 0, nOrigin,
-                                  nWidth, nHeight,
-                                  0, 0, nWidth, nHeight
+            POINTL vPoint2[4] = { {0, nOrigin},
+                                  {nWidth, nHeight},
+                                  {0, 0}, {nWidth, nHeight}

                                 };
             ::GpiBitBlt( hPSScreen
                         ,hPS
                                 };
             ::GpiBitBlt( hPSScreen
                         ,hPS


@@ -801,7 +838,7 @@ bool wxBitmap::CreateFromImage (
 
         pMask->SetMaskBitmap((WXHBITMAP)hBmp);
         SetMask(pMask);
 
         pMask->SetMaskBitmap((WXHBITMAP)hBmp);
         SetMask(pMask);

-        hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+        hBmpOld = ::GpiSetBitmap(hPS, hBmpOld);

     }
 
     //
     }
 
     //


@@ -809,9 +846,10 @@ bool wxBitmap::CreateFromImage (
     //
     ::GpiSetBitmap(hPS, NULLHANDLE);
     ::GpiDestroyPS(hPS);
     //
     ::GpiSetBitmap(hPS, NULLHANDLE);
     ::GpiDestroyPS(hPS);

+    ::DevCloseDC(hDCScreen);

     ::DevCloseDC(hDC);
     free(pucBits);
     ::DevCloseDC(hDC);
     free(pucBits);

-    return TRUE;
+    return true;

 } // end of wxBitmap::CreateFromImage
 
 wxImage wxBitmap::ConvertToImage() const
 } // end of wxBitmap::CreateFromImage
 
 wxImage wxBitmap::ConvertToImage() const


@@ -838,12 +876,11 @@ wxImage wxBitmap::ConvertToImage() const
     BITMAPINFOHEADER2               vDIBh;
     BITMAPINFO2                     vDIBInfo;
     HPS                             hPSMem;
     BITMAPINFOHEADER2               vDIBh;
     BITMAPINFO2                     vDIBInfo;
     HPS                             hPSMem;

-    HPS                             hPS;

     HBITMAP                         hBitmap;
     HBITMAP                         hOldBitmap;
     DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
     SIZEL                           vSizlPage = {0,0};
     HBITMAP                         hBitmap;
     HBITMAP                         hOldBitmap;
     DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
     SIZEL                           vSizlPage = {0,0};

-    HDC                             hDCMem;
+    HDC                             hDCMem = NULLHANDLE;

 
     vImage.Create( nWidth
                   ,nHeight
 
     vImage.Create( nWidth
                   ,nHeight


@@ -886,13 +923,18 @@ wxImage wxBitmap::ConvertToImage() const
         free(pData);
         return wxNullImage;
     }
         free(pData);
         return wxNullImage;
     }

+    memset(lpBits, '\0', (nBytePerLine * nHeight));
+    hBitmap = (HBITMAP)GetHBITMAP();

 
     //
     // May already be selected into a PS
     //
 
     //
     // May already be selected into a PS
     //

-    if ((pDC = GetSelectedInto()) != NULL)
+    pDC = GetSelectedInto();
+    const wxPMDCImpl *impl; 
+    if (pDC != NULL &&
+        (impl = wxDynamicCast( pDC->GetImpl(), wxPMDCImpl )) != NULL)

     {
     {

-        hPSMem = pDC->GetHPS();
+        hPSMem = impl->GetHPS();

     }
     else
     {
     }
     else
     {


@@ -908,15 +950,14 @@ wxImage wxBitmap::ConvertToImage() const
                                ,&vSizlPage
                                ,PU_PELS | GPIA_ASSOC
                               );
                                ,&vSizlPage
                                ,PU_PELS | GPIA_ASSOC
                               );

-        hBitmap = (HBITMAP)GetHBITMAP();
-        if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
-        {
-            ERRORID                 vError;
-            wxString                sError;
+    }
+    if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
+    {
+        ERRORID                 vError;
+        wxString                sError;

 
 

-            vError = ::WinGetLastError(vHabmain);
-            sError = wxPMErrorToStr(vError);
-        }
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);

     }
 
     //
     }
 
     //


@@ -982,7 +1023,7 @@ wxImage wxBitmap::ConvertToImage() const
         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) );


@@ -1026,11 +1067,11 @@ wxImage wxBitmap::ConvertToImage() const
                              ,ucGreen
                              ,ucBlue
                             );
                              ,ucGreen
                              ,ucBlue
                             );

-        vImage.SetMask(TRUE);
+        vImage.SetMask(true);

     }
     else
     {
     }
     else
     {

-        vImage.SetMask(FALSE);
+        vImage.SetMask(false);

     }
 
     //
     }
 
     //


@@ -1070,9 +1111,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] = { 0, 0, rRect.width, rRect.height,
-                                                  rRect.x, rRect.y,
-                                                  rRect.x + rRect.width, rRect.y + rRect.height
+    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());


@@ -1097,7 +1138,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


@@ -1145,17 +1186,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
 )


@@ -1174,9 +1204,7 @@ void wxBitmap::SetMask(
     GetBitmapData()->m_pBitmapMask = pMask;
 } // end of wxBitmap::SetMask
 
     GetBitmapData()->m_pBitmapMask = pMask;
 } // end of wxBitmap::SetMask
 

-wxBitmap wxBitmap::GetBitmapForDC(
-  wxDC&                             rDc
-) const
+wxBitmap wxBitmap::GetBitmapForDC(wxDC& WXUNUSED(rDc)) const

 {
     return(*this);
 } // end of wxBitmap::GetBitmapForDC
 {
     return(*this);
 } // end of wxBitmap::GetBitmapForDC


@@ -1190,6 +1218,11 @@ wxMask::wxMask()
     m_hMaskBitmap = 0;
 } // end of wxMask::wxMask
 
     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
 wxMask::wxMask(
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 wxMask::wxMask(


@@ -1243,8 +1276,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)


@@ -1254,7 +1287,7 @@ bool wxMask::Create(
     }
     if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
     {
     }
     if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
     {

-        return(FALSE);
+        return false;

     }
 
     memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
     }
 
     memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));


@@ -1262,7 +1295,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


@@ -1285,7 +1318,7 @@ bool wxMask::Create(
     ::GpiDestroyPS(hPSDst);
     ::DevCloseDC(hDCSrc);
     ::DevCloseDC(hDCDst);
     ::GpiDestroyPS(hPSDst);
     ::DevCloseDC(hDCSrc);
     ::DevCloseDC(hDCDst);

-    return(TRUE);
+    return true;

 } // end of wxMask::Create
 
 // Create a mask from a bitmap and a palette index indicating
 } // end of wxMask::Create
 
 // Create a mask from a bitmap and a palette index indicating


@@ -1322,7 +1355,7 @@ bool wxMask::Create(
                           ));
         }
     }
                           ));
         }
     }

-    return(FALSE);
+    return false;

 } // end of wxMask::Create
 
 // Create a mask from a bitmap and a colour indicating
 } // end of wxMask::Create
 
 // Create a mask from a bitmap and a colour indicating


@@ -1332,7 +1365,7 @@ bool wxMask::Create(
 , const wxColour&                   rColour
 )
 {
 , const wxColour&                   rColour
 )
 {

-    bool                            bOk = TRUE;
+    bool                            bOk = true;

     COLORREF                        vMaskColour = OS2RGB( rColour.Red()
                                                          ,rColour.Green()
                                                          ,rColour.Blue()
     COLORREF                        vMaskColour = OS2RGB( rColour.Red()
                                                          ,rColour.Green()
                                                          ,rColour.Blue()


@@ -1344,9 +1377,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)
     {


@@ -1355,7 +1385,7 @@ bool wxMask::Create(
     }
     if (!rBitmap.Ok())
     {
     }
     if (!rBitmap.Ok())
     {

-        return(FALSE);
+        return false;

     }
 
     //
     }
 
     //


@@ -1396,7 +1426,7 @@ bool wxMask::Create(
                 //
                 // Doesn't make sense to continue
                 //
                 //
                 // Doesn't make sense to continue
                 //

-                bOk = FALSE;
+                bOk = false;

                 break;
             }
 
                 break;
             }
 


@@ -1418,39 +1448,37 @@ bool wxMask::Create(
     ::GpiDestroyPS(hPSDst);
     ::DevCloseDC(hDCSrc);
     ::DevCloseDC(hDCDst);
     ::GpiDestroyPS(hPSDst);
     ::DevCloseDC(hDCSrc);
     ::DevCloseDC(hDCDst);

-    return(TRUE);
+    return true;

 } // end of wxMask::Create
 
 // ----------------------------------------------------------------------------
 // wxBitmapHandler
 // ----------------------------------------------------------------------------
 
 } // end of wxMask::Create
 
 // ----------------------------------------------------------------------------
 // wxBitmapHandler
 // ----------------------------------------------------------------------------
 

-bool wxBitmapHandler::Create(
-  wxGDIImage*                       pImage
-, void*                             pData
-, long                              lFlags
-, int                               nWidth
-, int                               nHeight
-, int                               nDepth
-)
+bool wxBitmapHandler::Create( wxGDIImage* pImage,
+                              const void* pData,
+                              wxBitmapType lType,
+                              int         nWidth,
+                              int         nHeight,
+                              int         nDepth)

 {
 {

-    wxBitmap*                       pBitmap = wxDynamicCast( pImage
-                                                            ,wxBitmap
-                                                           );
+    wxBitmap* pBitmap = wxDynamicCast( pImage
+                                      ,wxBitmap
+                                       );

 
     return(pBitmap ? Create( pBitmap
                             ,pData
 
     return(pBitmap ? Create( pBitmap
                             ,pData

+                            ,lType

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

-                           ) : FALSE);
+                           ) : false);

 }
 
 bool wxBitmapHandler::Load(
   wxGDIImage*                       pImage
 }
 
 bool wxBitmapHandler::Load(
   wxGDIImage*                       pImage

-, const wxString&                   rName
-, HPS                               hPs
-, long                              lFlags
+, int                               nId
+, wxBitmapType                      lFlags

 , int                               nWidth
 , int                               nHeight
 )
 , int                               nWidth
 , int                               nHeight
 )


@@ -1460,19 +1488,18 @@ bool wxBitmapHandler::Load(
                                                            );
 
     return(pBitmap ? LoadFile( pBitmap
                                                            );
 
     return(pBitmap ? LoadFile( pBitmap

-                              ,rName
-                              ,hPs
+                              ,nId

                               ,lFlags
                               ,nWidth
                               ,nHeight
                               ,lFlags
                               ,nWidth
                               ,nHeight

-                             ) : FALSE);
+                             ) : false);

 }
 
 bool wxBitmapHandler::Save(
 }
 
 bool wxBitmapHandler::Save(

-  wxGDIImage*                       pImage
+  const wxGDIImage*                 pImage

 , const wxString&                   rName
 , const wxString&                   rName

-, int                               lType
-)
+, wxBitmapType                      lType
+) const

 {
     wxBitmap*                       pBitmap = wxDynamicCast( pImage
                                                             ,wxBitmap
 {
     wxBitmap*                       pBitmap = wxDynamicCast( pImage
                                                             ,wxBitmap


@@ -1481,41 +1508,51 @@ bool wxBitmapHandler::Save(
     return(pBitmap ? SaveFile( pBitmap
                               ,rName
                               ,lType
     return(pBitmap ? SaveFile( pBitmap
                               ,rName
                               ,lType

-                             ) : FALSE);
+                             ) : false);

 }
 
 bool wxBitmapHandler::Create(
   wxBitmap*                         WXUNUSED(pBitmap)
 }
 
 bool wxBitmapHandler::Create(
   wxBitmap*                         WXUNUSED(pBitmap)

-, void*                             WXUNUSED(pData)
-, long                              WXUNUSED(lType)
+, const void*                       WXUNUSED(pData)
+, wxBitmapType                      WXUNUSED(lType)

 , int                               WXUNUSED(nWidth)
 , int                               WXUNUSED(nHeight)
 , int                               WXUNUSED(nDepth)
 )
 {
 , int                               WXUNUSED(nWidth)
 , int                               WXUNUSED(nHeight)
 , int                               WXUNUSED(nDepth)
 )
 {

-    return(FALSE);
+    return false;
+}
+
+bool wxBitmapHandler::LoadFile(
+  wxBitmap*                         WXUNUSED(pBitmap)
+, int                               WXUNUSED(nId)
+, wxBitmapType                      WXUNUSED(lType)
+, int                               WXUNUSED(nDesiredWidth)
+, int                               WXUNUSED(nDesiredHeight)
+)
+{
+    return false;

 }
 
 bool wxBitmapHandler::LoadFile(
   wxBitmap*                         WXUNUSED(pBitmap)
 , const wxString&                   WXUNUSED(rName)
 }
 
 bool wxBitmapHandler::LoadFile(
   wxBitmap*                         WXUNUSED(pBitmap)
 , const wxString&                   WXUNUSED(rName)

-, HPS                               WXUNUSED(hPs)
-, long                              WXUNUSED(lType)
+, wxBitmapType                      WXUNUSED(lType)

 , int                               WXUNUSED(nDesiredWidth)
 , int                               WXUNUSED(nDesiredHeight)
 )
 {
 , int                               WXUNUSED(nDesiredWidth)
 , int                               WXUNUSED(nDesiredHeight)
 )
 {

-    return(FALSE);
+    return false;

 }
 
 bool wxBitmapHandler::SaveFile(
   wxBitmap*                         WXUNUSED(pBitmap)
 , const wxString&                   WXUNUSED(rName)
 }
 
 bool wxBitmapHandler::SaveFile(
   wxBitmap*                         WXUNUSED(pBitmap)
 , const wxString&                   WXUNUSED(rName)

-, int                               WXUNUSED(nType)
+, wxBitmapType                      WXUNUSED(nType)

 , const wxPalette*                  WXUNUSED(pPalette)
 , const wxPalette*                  WXUNUSED(pPalette)

-)
+) const

 {
 {

-    return(FALSE);
+    return false;

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


@@ -1552,16 +1589,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


@@ -1589,3 +1626,83 @@ HBITMAP wxInvertMask(
     return hBmpInvMask;
 } // end of WxWinGdi_InvertMask
 
     return hBmpInvMask;
 } // end of WxWinGdi_InvertMask
 

+HBITMAP wxCopyBmp( HBITMAP hBmp, bool flip, int nWidth, int nHeight )
+{
+    wxCHECK_MSG( hBmp, 0, _T("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