Since I have made several changes to SWIG over the years to accomodate

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

diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp
index eb52b51de1fdc61911bc55e8d99cc3d81f239e4b..486cfed0af29d1d1e9dde1f5067d1f5b2989952b 100644 (file)
--- a/src/os2/bitmap.cpp
+++ b/src/os2/bitmap.cpp
@@ -33,6 +33,7 @@
 
 //#include "wx/msw/dib.h"
 #include "wx/image.h"
 
 //#include "wx/msw/dib.h"
 #include "wx/image.h"

+#include "wx/xpmdecod.h"

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


@@ -62,12 +63,13 @@ wxBitmapRefData::wxBitmapRefData()
 
 void wxBitmapRefData::Free()
 {
 
 void wxBitmapRefData::Free()
 {

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

     if (m_hBitmap)
     {
     if (m_hBitmap)
     {

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

         {
             wxLogLastError("GpiDeleteBitmap(hbitmap)");
         }
         {
             wxLogLastError("GpiDeleteBitmap(hbitmap)");
         }


@@ -84,10 +86,6 @@ void wxBitmapRefData::Free()
 // this function should be called from all wxBitmap ctors
 void wxBitmap::Init()
 {
 // this function should be called from all wxBitmap ctors
 void wxBitmap::Init()
 {

-    // m_refData = NULL; done in the base class ctor
-
-    if (wxTheBitmapList)
-        wxTheBitmapList->AddBitmap(this);

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


@@ -146,15 +144,13 @@ bool wxBitmap::CopyFromIcon(
 
 wxBitmap::~wxBitmap()
 {
 
 wxBitmap::~wxBitmap()
 {

-    if (wxTheBitmapList)
-        wxTheBitmapList->DeleteObject(this);

 } // end of wxBitmap::~wxBitmap
 
 wxBitmap::wxBitmap(
   const char                        zBits[]
 } // end of wxBitmap::~wxBitmap
 
 wxBitmap::wxBitmap(
   const char                        zBits[]

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

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


@@ -166,80 +162,97 @@ wxBitmap::wxBitmap(
     HPS                             hPs;
     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
     SIZEL                           vSize = {0, 0};
     HPS                             hPs;
     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
     SIZEL                           vSize = {0, 0};

+    char*                           pzData;

 
     wxASSERT(vHabmain != NULL);
 
 
     wxASSERT(vHabmain != NULL);
 

-    hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+    m_refData = pRefData;

 
 

-    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;
+    pRefData->m_nWidth        = nWidth;
+    pRefData->m_nHeight       = nHeight;
+    pRefData->m_nDepth        = nDepth;
+    pRefData->m_nNumColors    = 0;
+    pRefData->m_pSelectedInto = NULL;

 
 

+    hDc   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);

     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
     if (hPs == 0)
     {
         wxLogLastError("GpiCreatePS Failure");
     }
 
     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
     if (hPs == 0)
     {
         wxLogLastError("GpiCreatePS Failure");
     }
 

-    m_refData = pRefData;
-
-    pRefData->m_nWidth = nTheWidth;
-    pRefData->m_nHeight = nTheHeight;
-    pRefData->m_nDepth = nNoBits;
-    pRefData->m_nNumColors = 0;
-    pRefData->m_pSelectedInto = NULL;
+    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 inversed!
+        //
+        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;

 
 

-    HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
-    if (!hBmp)
+                for (nBits = 0; nBits < 8; nBits++)
+                {
+                    ucReversed <<= 1;
+                    ucReversed |= (ucVal & 0x01);
+                    ucVal >>= 1;
+                }
+                *pzDst++ = ucReversed;
+            }
+            if (nPadding)
+                *pzDst++ = 0;
+        }
+    }
+    else

     {
     {

-        wxLogLastError("CreateBitmap");
+        //
+        // Bits should already be in Windows standard format
+        //
+        pzData = (char *)zBits;    // const_cast is harmless

     }
     }

-    SetHBITMAP((WXHBITMAP)hBmp);
-} // end of wxBitmap::wxBitmap

 
 

-//
-// Create from XPM data
-//
-wxBitmap::wxBitmap(
-  char**                            ppData
-)
-{
-    Init();
+    if (nDepth > 24)
+        nDepth = 24; // MAX supported in PM
+    memset(&vHeader, '\0', 16);
+    vHeader.cbFix           = 16;
+    vHeader.cx              = (USHORT)nWidth;
+    vHeader.cy              = (USHORT)nHeight;
+    vHeader.cPlanes         = 1L;
+    vHeader.cBitCount       = nDepth;
+    vHeader.usReserved      = 0;

 
 

-    (void)Create( (void *)ppData
-                 ,wxBITMAP_TYPE_XPM_DATA
-                 ,0
-                 ,0
-                 ,0
-                );
-} // end of wxBitmap::wxBitmap
+    memset(&vInfo, '\0', 16);
+    vInfo.cbFix           = 16;
+    vInfo.cx              = (USHORT)nWidth;
+    vInfo.cy              = (USHORT)nHeight;
+    vInfo.cPlanes         = 1L;
+    vInfo.cBitCount       = nDepth;

 
 

-wxBitmap::wxBitmap(
-  const char**                      ppData
-)
-{
-    Init();
+    HBITMAP                         hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);

 
 

-    (void)Create( (void *)ppData
-                 ,wxBITMAP_TYPE_XPM_DATA
-                 ,0
-                 ,0
-                 ,0
-                );
+    if (!hBmp)
+    {
+        wxLogLastError("CreateBitmap");
+    }
+    ::GpiDestroyPS(hPs);
+    ::DevCloseDC(hDc);
+    SetHBITMAP((WXHBITMAP)hBmp);

 } // end of wxBitmap::wxBitmap
 
 wxBitmap::wxBitmap(
 } // end of wxBitmap::wxBitmap
 
 wxBitmap::wxBitmap(


@@ -309,8 +322,8 @@ bool wxBitmap::Create(
         HDC                         hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
         HPS                         hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 
         HDC                         hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
         HPS                         hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 

-        memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
-        vHeader.cbFix     =  sizeof(BITMAPINFOHEADER2);
+        memset(&vHeader, '\0', 16);
+        vHeader.cbFix     =  16;

         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;


@@ -335,8 +348,11 @@ bool wxBitmap::Create(
         hDCScreen = ::GpiQueryDevice(hPSScreen);
         ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 
         hDCScreen = ::GpiQueryDevice(hPSScreen);
         ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 

-        memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
-        vHeader.cbFix     =  sizeof(BITMAPINFOHEADER2);
+        if (lBitCount > 24)
+            lBitCount = 24;
+
+        memset(&vHeader, '\0', 16);
+        vHeader.cbFix     =  16;

         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;
         vHeader.cx        = nW;
         vHeader.cy        = nH;
         vHeader.cPlanes   = 1;


@@ -361,6 +377,27 @@ bool wxBitmap::Create(
     return Ok();
 } // end of wxBitmap::Create
 
     return Ok();
 } // end of wxBitmap::Create
 

+bool wxBitmap::CreateFromXpm(
+  const char**                      ppData
+)
+{
+#if wxUSE_IMAGE && wxUSE_XPM
+    Init();
+
+    wxCHECK_MSG(ppData != NULL, FALSE, wxT("invalid bitmap data"))
+
+    wxXPMDecoder                    vDecoder;
+    wxImage                         vImg = vDecoder.ReadData(ppData);
+
+    wxCHECK_MSG(vImg.Ok(), FALSE, wxT("invalid bitmap data"))
+
+    *this = wxBitmap(vImg);
+    return TRUE;
+#else
+    return FALSE;
+#endif
+} // end of wxBitmap::CreateFromXpm
+

 bool wxBitmap::LoadFile(
   const wxString&                   rFilename
 , long                              lType
 bool wxBitmap::LoadFile(
   const wxString&                   rFilename
 , long                              lType


@@ -393,7 +430,7 @@ bool wxBitmap::LoadFile(
         if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
             return(FALSE);
 
         if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
             return(FALSE);
 

-        *this = vImage.ConvertToBitmap();
+        *this = wxBitmap(vImage);

 
         return(TRUE);
     }
 
         return(TRUE);
     }


@@ -453,7 +490,7 @@ bool wxBitmap::SaveFile(
     else
     {
         // FIXME what about palette? shouldn't we use it?
     else
     {
         // FIXME what about palette? shouldn't we use it?

-        wxImage                     vImage(*this);
+        wxImage                     vImage = ConvertToImage();

 
         if (!vImage.Ok())
             return(FALSE);
 
         if (!vImage.Ok())
             return(FALSE);


@@ -469,335 +506,556 @@ bool wxBitmap::SaveFile(
 // wxImage-wxBitmap convertion
 // ----------------------------------------------------------------------------
 
 // wxImage-wxBitmap convertion
 // ----------------------------------------------------------------------------
 

-bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
+bool wxBitmap::CreateFromImage (
+  const wxImage&                    rImage
+, int                               nDepth
+)

 {
 {

-    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
-
-// TODO:
-/*
-    int sizeLimit = 1024*768*3;
-
-    // width and height of the device-dependent bitmap
-    int width = GetWidth();
-    int bmpHeight = GetHeight();
-
-    // calc the number of bytes per scanline and padding
-    int bytePerLine = width*3;
-    int sizeDWORD = sizeof( DWORD );
-    int lineBoundary = bytePerLine % sizeDWORD;
-    int padding = 0;
-    if( lineBoundary > 0 )
+    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)

     {
     {

-        padding = sizeDWORD - lineBoundary;
-        bytePerLine += padding;
+        nPadding = nSizeDWORD - nLineBoundary;
+        nBytePerLine += nPadding;

     }
     }

-    // calc the number of DIBs and heights of DIBs
-    int numDIB = 1;
-    int hRemain = 0;
-    int height = sizeLimit/bytePerLine;
-    if( height >= bmpHeight )
-        height = bmpHeight;
+
+    //
+    // Calc the number of DIBs and heights of DIBs
+    //
+    int                             nNumDIB = 1;
+    int                             nHRemain = 0;
+    int                             nHeight = nSizeLimit / nBytePerLine;
+
+    if (nHeight >= nBmpHeight)
+        nHeight = nBmpHeight;

     else
     {
     else
     {

-        numDIB =  bmpHeight / height;
-        hRemain = bmpHeight % height;
-        if( hRemain >0 )  numDIB++;
+        nNumDIB  = nBmpHeight / nHeight;
+        nHRemain = nBmpHeight % nHeight;
+        if (nHRemain > 0)
+            nNumDIB++;

     }
 
     }
 

-    // set bitmap parameters
-    wxBitmap bitmap;
-    wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
-    bitmap.SetWidth( width );
-    bitmap.SetHeight( bmpHeight );
-    bitmap.SetDepth( wxDisplayDepth() );
-
-    // create a DIB header
-    int headersize = sizeof(BITMAPINFOHEADER);
-    LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
-    wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
+    //
+    // Set bitmap parameters
+    //
+    wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+    SetWidth(nWidth);
+    SetHeight(nBmpHeight);
+    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;
+    LONG                            alFormats[24]; // Max formats OS/2 PM supports
+    ULONG                           ulBitcount;
+
+    //

     // Fill in the DIB header
     // Fill in the DIB header

-    lpDIBh->bmiHeader.biSize = headersize;
-    lpDIBh->bmiHeader.biWidth = (DWORD)width;
-    lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
-    lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
-    //   the general formula for biSizeImage:
-    //      ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
-    lpDIBh->bmiHeader.biPlanes = 1;
-    lpDIBh->bmiHeader.biBitCount = 24;
-    lpDIBh->bmiHeader.biCompression = BI_RGB;
-    lpDIBh->bmiHeader.biClrUsed = 0;
-    // These seem not really needed for our purpose here.
-    lpDIBh->bmiHeader.biClrImportant = 0;
-    lpDIBh->bmiHeader.biXPelsPerMeter = 0;
-    lpDIBh->bmiHeader.biYPelsPerMeter = 0;
-    // memory for DIB data
-    unsigned char *lpBits;
-    lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
-    if( !lpBits )
+    //
+    memset(&vHeader, '\0', 16);
+    vHeader.cbFix           = 16;
+    vHeader.cx              = (ULONG)nWidth;
+    vHeader.cy              = (ULONG)nHeight;
+    vHeader.cPlanes         = 1L;
+    vHeader.cBitCount       = 24;
+
+    //
+    // Memory for DIB data
+    //
+    unsigned char*                  pucBits;
+
+    pucBits = (unsigned char *)malloc(nBytePerLine * nHeight);
+    if(!pucBits)
+    {
+        wxFAIL_MSG(wxT("could not allocate memory for DIB"));
+        return FALSE;
+    }
+
+    //
+    // 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;
+
+    ::GpiQueryDeviceBitmapFormats(hPS, 24, alFormats);
+    ulBitcount = alFormats[1]; // the best one for the device
+    if (ulBitcount > 24)
+        ulBitcount = 24;  // MAX bits supported by PM
+    memset(&vInfo, '\0', 16);
+    vInfo.cbFix           = 16;
+    vInfo.cx              = (ULONG)nWidth;
+    vInfo.cy              = (ULONG)nHeight;
+    vInfo.cPlanes         = 1;
+    vInfo.cBitCount       = ulBitcount;
+
+    hBmp = ::GpiCreateBitmap( hPS
+                             ,&vHeader
+                             ,0L
+                             ,NULL
+                             ,NULL
+                            );
+    hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+#if wxUSE_PALETTE
+    HPAL                            hOldPalette = NULLHANDLE;
+    if (rImage.GetPalette().Ok())

     {
     {

-        wxFAIL_MSG( wxT("could not allocate memory for DIB") );
-        free( lpDIBh );
-        return bitmap;
+        hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE());

     }
     }

+#endif // wxUSE_PALETTE

 
 

-    // create and set the device-dependent bitmap
-    HDC hdc = ::GetDC(NULL);
-    HDC memdc = ::CreateCompatibleDC( hdc );
-    HBITMAP hbitmap;
-    hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
-    ::SelectObject( memdc, hbitmap);
-
-    // copy image data into DIB data and then into DDB (in a loop)
-    unsigned char *data = GetData();
-    int i, j, n;
-    int origin = 0;
-    unsigned char *ptdata = data;
-    unsigned char *ptbits;
-
-    for( n=0; n<numDIB; n++ )
+    //
+    // 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;
+
+    for (n = 0; n < nNumDIB; n++)

     {
     {

-        if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
+        if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)

         {
         {

-            // redefine height and size of the (possibly) last smaller DIB
+            //
+            // Redefine height and size of the (possibly) last smaller DIB

             // memory is not reallocated
             // memory is not reallocated

-            height = hRemain;
-            lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
-            lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+            //
+            nHeight         = nHRemain;
+            vHeader.cy      = (DWORD)(nHeight);
+            vHeader.cbImage = nBytePerLine * nHeight;

         }
         }

-        ptbits = lpBits;
-
-        for( j=0; j<height; j++ )
+        ptbits = pucBits;
+        for (j = 0; j < nHeight; j++)

         {
         {

-            for( i=0; i<width; i++ )
+            for (i = 0; i < nWidth; i++)

             {
             {

-                *(ptbits++) = *(ptdata+2);
-                *(ptbits++) = *(ptdata+1);
-                *(ptbits++) = *(ptdata  );
+                *(ptbits++) = *(ptdata + 2);
+                *(ptbits++) = *(ptdata + 1);
+                *(ptbits++) = *(ptdata);

                 ptdata += 3;
             }
                 ptdata += 3;
             }

-            for( i=0; i< padding; i++ )   *(ptbits++) = 0;
+            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;
+
+            vError = ::WinGetLastError(vHabmain);
+            sError = wxPMErrorToStr(vError);

         }
         }

-        ::StretchDIBits( memdc, 0, origin, width, height,\
-            0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
-        origin += height;
-        // if numDIB = 1,  lines below can also be used
-        //    hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
-        // The above line is equivalent to the following two lines.
-        //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
-        //    ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
-        // or the following lines
-        //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
-        //    HDC memdc = ::CreateCompatibleDC( hdc );
-        //    ::SelectObject( memdc, hbitmap);
-        //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,
-        //            0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
-        //    ::SelectObject( memdc, 0 );
-        //    ::DeleteDC( memdc );
+
+        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;

     }
     }

-    bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
+    SetHBITMAP((WXHBITMAP)hBmp);
+#if wxUSE_PALETTE
+    if (hOldPalette)
+        ::GpiSelectPalette(hPS, hOldPalette);
+#endif // wxUSE_PALETTE

 
 

-    // similarly, created an mono-bitmap for the possible mask
-    if( HasMask() )
+    //
+    // Similarly, created an mono-bitmap for the possible mask
+    //
+    if (rImage.HasMask())

     {
     {

-        hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
-        ::SelectObject( memdc, hbitmap);
-        if( numDIB == 1 )   height = bmpHeight;
-        else                height = sizeLimit/bytePerLine;
-        lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
-        lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
-        origin = 0;
-        unsigned char r = GetMaskRed();
-        unsigned char g = GetMaskGreen();
-        unsigned char b = GetMaskBlue();
-        unsigned char zero = 0, one = 255;
-        ptdata = data;
-        for( n=0; n<numDIB; n++ )
+        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( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
+            if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)

             {
             {

-                // redefine height and size of the (possibly) last smaller DIB
+                //
+                // Redefine height and size of the (possibly) last smaller DIB

                 // memory is not reallocated
                 // memory is not reallocated

-                height = hRemain;
-                lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
-                lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+                //
+                nHeight         = nHRemain;
+                vHeader.cy      = (DWORD)(nHeight);

             }
             }

-            ptbits = lpBits;
-            for( int j=0; j<height; j++ )
+            ptbits = pucBits;
+            for (int j = 0; j < nHeight; j++)

             {
             {

-                for(i=0; i<width; i++ )
+                for (i = 0; i < nWidth; i++)

                 {
                 {

-                    if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
+                    if ((*(ptdata++) != cRed) || (*(ptdata++) != cGreen) || (*(ptdata++) != cBlue))

                     {
                     {

-                        *(ptbits++) = one;
-                        *(ptbits++) = one;
-                        *(ptbits++) = one;
+                        *(ptbits++) = cOne;
+                        *(ptbits++) = cOne;
+                        *(ptbits++) = cOne;

                     }
                     else
                     {
                     }
                     else
                     {

-                        *(ptbits++) = zero;
-                        *(ptbits++) = zero;
-                        *(ptbits++) = zero;
+                        *(ptbits++) = cZero;
+                        *(ptbits++) = cZero;
+                        *(ptbits++) = cZero;

                     }
                 }
                     }
                 }

-                for( i=0; i< padding; i++ )   *(ptbits++) = zero;
+                for (i = 0; i < nPadding; i++)
+                    *(ptbits++) = cZero;

             }
             }

-            ::StretchDIBits( memdc, 0, origin, width, height,\
-                0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
-            origin += height;
+            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 *mask = new wxMask();
-        mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
-        bitmap.SetMask( mask );
-    }

 
 

-    // free allocated resources
-    ::SelectObject( memdc, 0 );
-    ::DeleteDC( memdc );
-    ::ReleaseDC(NULL, hdc);
-    free(lpDIBh);
-    free(lpBits);
+        //
+        // Create a wxMask object
+        //
+        wxMask*                     pMask = new wxMask();

 
 

-    // check the wxBitmap object
-    if( bitmap.GetHBITMAP() )
-        bitmap.SetOk( TRUE );
-    else
-        bitmap.SetOk( FALSE );
-*/
+        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;
     return TRUE;

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

 
 wxImage wxBitmap::ConvertToImage() const
 {
 
 wxImage wxBitmap::ConvertToImage() const
 {

-    wxImage image;
-    
+    wxImage                         vImage;
+    wxDC*                           pDC;
+

     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 

-    // create an wxImage object
-    int width = GetWidth();
-    int height = GetHeight();
-    image.Create( width, height );
-    unsigned char *data = image.GetData();
-    if( !data )
+    //
+    // 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;
+    HPS                             hPS;
+    HBITMAP                         hBitmap;
+    HBITMAP                         hOldBitmap;
+    DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+    SIZEL                           vSizlPage = {0,0};
+    HDC                             hDCMem;
+    LONG                            alFormats[24]; // 24 is MAX formats supported
+    ULONG                           ulBitcount;
+
+    ::GpiQueryDeviceBitmapFormats(hPS, 24, alFormats);
+    ulBitcount = alFormats[1]; // the best one
+    if (ulBitcount > 24) // PM supports a max of 24
+        ulBitcount = 24;
+    vImage.Create( nWidth
+                  ,nHeight
+                 );
+    pData = vImage.GetData();
+    if(!pData)

     {
         wxFAIL_MSG( wxT("could not allocate data for image") );
         return wxNullImage;
     }
     {
         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       = ulBitcount;
+
+    lpBits = (unsigned char *)malloc(nBytePerLine * nHeight);
+    if (!lpBits)
+    {
+        wxFAIL_MSG(wxT("could not allocate data for DIB"));
+        free(pData);
+        return wxNullImage;
+    }

 
 

-    // calc the number of bytes per scanline and padding in the DIB
-    int bytePerLine = width*3;
-    int sizeDWORD = sizeof( DWORD );
-    int lineBoundary =  bytePerLine % sizeDWORD;
-    int padding = 0;
-    if( lineBoundary > 0 )
+    //
+    // May already be selected into a PS
+    //
+    if ((pDC = GetSelectedInto()) != NULL)

     {
     {

-        padding = sizeDWORD - lineBoundary;
-        bytePerLine += padding;
+        hPSMem = pDC->GetHPS();

     }
     }

-// TODO:
-/*
-    // create a DIB header
-    int headersize = sizeof(BITMAPINFOHEADER);
-    LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
-    if( !lpDIBh )
+    else

     {
     {

-        wxFAIL_MSG( wxT("could not allocate data for DIB header") );
-        free( data );
-        return;
+        hDCMem = ::DevOpenDC( vHabmain
+                             ,OD_MEMORY
+                             ,"*"
+                             ,5L
+                             ,(PDEVOPENDATA)&vDop
+                             ,NULLHANDLE
+                            );
+        hPSMem = ::GpiCreatePS( vHabmain
+                               ,hDCMem
+                               ,&vSizlPage
+                               ,PU_PELS | GPIA_ASSOC
+                              );
+        hBitmap = (HBITMAP)GetHBITMAP();
+        if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
+        {
+            ERRORID                 vError;
+            wxString                sError;
+
+            vError = ::WinGetLastError(vHabmain);
+            sError = wxPMErrorToStr(vError);
+        }

     }
     }

-    // Fill in the DIB header
-    lpDIBh->bmiHeader.biSize = headersize;
-    lpDIBh->bmiHeader.biWidth = width;
-    lpDIBh->bmiHeader.biHeight = -height;
-    lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
-    lpDIBh->bmiHeader.biPlanes = 1;
-    lpDIBh->bmiHeader.biBitCount = 24;
-    lpDIBh->bmiHeader.biCompression = BI_RGB;
-    lpDIBh->bmiHeader.biClrUsed = 0;
-    // These seem not really needed for our purpose here.
-    lpDIBh->bmiHeader.biClrImportant = 0;
-    lpDIBh->bmiHeader.biXPelsPerMeter = 0;
-    lpDIBh->bmiHeader.biYPelsPerMeter = 0;
-    // memory for DIB data
-    unsigned char *lpBits;
-    lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
-    if( !lpBits )
+
+    //
+    // Copy data from the device-dependent bitmap to the DIB
+    //
+    if ((lScans = ::GpiQueryBitmapBits( hPSMem
+                                       ,0L
+                                       ,(LONG)nHeight
+                                       ,(PBYTE)lpBits
+                                       ,&vDIBInfo
+                                      )) == GPI_ALTERROR)

     {
     {

-        wxFAIL_MSG( wxT("could not allocate data for DIB") );
-        free( data );
-        free( lpDIBh );
-        return;
+        ERRORID                     vError;
+        wxString                    sError;
+
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);

     }
 
     }
 

-    // copy data from the device-dependent bitmap to the DIB
-    HDC hdc = ::GetDC(NULL);
-    HBITMAP hbitmap;
-    hbitmap = (HBITMAP) bitmap.GetHBITMAP();
-    ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
-
-    // copy DIB data into the wxImage object
-    int i, j;
-    unsigned char *ptdata = data;
-    unsigned char *ptbits = lpBits;
-    for( i=0; i<height; i++ )
+    //
+    // Copy DIB data into the wxImage object
+    //
+    int                             i;
+    int                             j;
+    unsigned char*                  ptdata = pData;
+    unsigned char*                  ptbits = lpBits;
+
+    for (i = 0; i < nHeight; i++)

     {
     {

-        for( j=0; j<width; j++ )
+        for (j = 0; j < nWidth; j++)

         {
             *(ptdata++) = *(ptbits+2);
             *(ptdata++) = *(ptbits+1);
             *(ptdata++) = *(ptbits  );
             ptbits += 3;
         }
         {
             *(ptdata++) = *(ptbits+2);
             *(ptdata++) = *(ptbits+1);
             *(ptdata++) = *(ptbits  );
             ptbits += 3;
         }

-        ptbits += padding;
+        ptbits += nPadding;
+    }
+    if ((pDC = GetSelectedInto()) == NULL)
+    {
+        ::GpiSetBitmap(hPSMem, NULLHANDLE);
+        ::GpiDestroyPS(hPSMem);
+        ::DevCloseDC(hDCMem);

     }
 
     }
 

-    // similarly, set data according to the possible mask bitmap
-    if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
+    //
+    // Similarly, set data according to the possible mask bitmap
+    //
+    if (GetMask() && GetMask()->GetMaskBitmap())

     {
     {

-        hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
-        // memory DC created, color set, data copied, and memory DC deleted
-        HDC memdc = ::CreateCompatibleDC( hdc );
-        ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
-        ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
-        ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
-        ::DeleteDC( memdc );
-        // background color set to RGB(16,16,16) in consistent with wxGTK
-        unsigned char r=16, g=16, b=16;
-        ptdata = data;
+        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;
         ptbits = lpBits;

-        for( i=0; i<height; i++ )
+        for (i = 0; i < nHeight; i++)

         {
         {

-            for( j=0; j<width; j++ )
+            for (j = 0; j < nWidth; j++)

             {
             {

-                if( *ptbits != 0 )
+                if (*ptbits != 0)

                     ptdata += 3;
                 else
                 {
                     ptdata += 3;
                 else
                 {

-                    *(ptdata++)  = r;
-                    *(ptdata++)  = g;
-                    *(ptdata++)  = b;
+                    *(ptdata++)  = ucRed;
+                    *(ptdata++)  = ucGreen;
+                    *(ptdata++)  = ucBlue;

                 }
                 ptbits += 3;
             }
                 }
                 ptbits += 3;
             }

-            ptbits += padding;
+            ptbits += nPadding;

         }
         }

-        SetMaskColour( r, g, b );
-        SetMask( TRUE );
+        vImage.SetMaskColour( ucRed
+                             ,ucGreen
+                             ,ucBlue
+                            );
+        vImage.SetMask(TRUE);

     }
     else
     {
     }
     else
     {

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

     }
     }

-    // free allocated resources
-    ::ReleaseDC(NULL, hdc);
-    free(lpDIBh);
-    free(lpBits);
-*/
-
-    return image;
-}

 
 

+    //
+    // Free allocated resources
+    //
+    free(lpBits);
+    return vImage;
+} // end of wxBitmap::ConvertToImage

 
 // ----------------------------------------------------------------------------
 // sub bitmap extraction
 
 // ----------------------------------------------------------------------------
 // sub bitmap extraction


@@ -829,9 +1087,9 @@ wxBitmap wxBitmap::GetSubBitmap(
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);

-    POINTL                          vPoint[4] = { rRect.x, rRect.y,
-                                                  rRect.x + rRect.width, rRect.y + rRect.height,
-                                                  0, 0, GetWidth(), GetHeight()
+    POINTL                          vPoint[4] = { 0, 0, rRect.width, rRect.height,
+                                                  rRect.x, rRect.y,
+                                                  rRect.x + rRect.width, rRect.y + rRect.height

                                                 };
 
     ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
                                                 };
 
     ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());


@@ -933,34 +1191,11 @@ void wxBitmap::SetMask(
     GetBitmapData()->m_pBitmapMask = pMask;
 } // end of wxBitmap::SetMask
 
     GetBitmapData()->m_pBitmapMask = pMask;
 } // end of wxBitmap::SetMask
 

-//
-// Will try something for OS/2 but not really sure how close
-// to the msw intent this is.
-//

 wxBitmap wxBitmap::GetBitmapForDC(
   wxDC&                             rDc
 ) const
 {
 wxBitmap wxBitmap::GetBitmapForDC(
   wxDC&                             rDc
 ) const
 {

-    wxMemoryDC                      vMemDC;
-    wxBitmap                        vTmpBitmap( this->GetWidth()
-                                               ,this->GetHeight()
-                                               ,rDc.GetDepth()
-                                              );
-    WXHBITMAP                       vOldBitmap;
-    HPS                             hMemoryPS;
-    HPS                             hPs;
-    POINTL                          vPoint[4];
-    SIZEL                           vSize = {0,0};
-
-    hMemoryPS = ::GpiCreatePS(vHabmain, (HDC)vMemDC.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
-    hPs       = ::GpiCreatePS(vHabmain, (HDC)rDc.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
-
-    // TODO: Set the points
-
-    vOldBitmap = (WXHBITMAP)::GpiSetBitmap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
-    ::GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY, BBO_IGNORE);
-
-    return(vTmpBitmap);
+    return(*this);

 } // end of wxBitmap::GetBitmapForDC
 
 // ----------------------------------------------------------------------------
 } // end of wxBitmap::GetBitmapForDC
 
 // ----------------------------------------------------------------------------


@@ -1370,3 +1605,4 @@ HBITMAP wxInvertMask(
 
     return hBmpInvMask;
 } // end of WxWinGdi_InvertMask
 
     return hBmpInvMask;
 } // end of WxWinGdi_InvertMask

+