src/os2/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        bitmap.cpp
   3 // Purpose:     wxBitmap
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     08/08/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "bitmap.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifndef WX_PRECOMP
  20     #include <stdio.h>
  21
  22     #include "wx/list.h"
  23     #include "wx/utils.h"
  24     #include "wx/app.h"
  25     #include "wx/palette.h"
  26     #include "wx/dcmemory.h"
  27     #include "wx/bitmap.h"
  28     #include "wx/icon.h"
  29 #endif
  30
  31 #include "wx/os2/private.h"
  32 #include "wx/log.h"
  33
  34 //#include "wx/msw/dib.h"
  35 #include "wx/image.h"
  36 #include "wx/xpmdecod.h"
  37
  38 // ----------------------------------------------------------------------------
  39 // macros
  40 // ----------------------------------------------------------------------------
  41
  42 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
  43 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  44
  45 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
  46
  47 // ============================================================================
  48 // implementation
  49 // ============================================================================
  50
  51 // ----------------------------------------------------------------------------
  52 // wxBitmapRefData
  53 // ----------------------------------------------------------------------------
  54
  55 wxBitmapRefData::wxBitmapRefData()
  56 {
  57     m_nQuality      = 0;
  58     m_pSelectedInto = NULL;
  59     m_nNumColors    = 0;
  60     m_pBitmapMask   = NULL;
  61     m_hBitmap       = (WXHBITMAP) NULL;
  62 } // end of wxBitmapRefData::wxBitmapRefData
  63
  64 void wxBitmapRefData::Free()
  65 {
  66     if ( m_pSelectedInto )
  67     {
  68         wxLogLastError("GpiDeleteBitmap(hbitmap)");
  69     }
  70     if (m_hBitmap)
  71     {
  72         if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
  73         {
  74             wxLogLastError("GpiDeleteBitmap(hbitmap)");
  75         }
  76     }
  77     if (m_pBitmapMask)
  78     {
  79         delete m_pBitmapMask;
  80         m_pBitmapMask = NULL;
  81     }
  82 } // end of wxBitmapRefData::Free
  83
  84 // ----------------------------------------------------------------------------
  85 // wxBitmap creation
  86 // ----------------------------------------------------------------------------
  87
  88 // this function should be called from all wxBitmap ctors
  89 void wxBitmap::Init()
  90 {
  91     m_bIsMono = FALSE;
  92     //
  93     // True for all bitmaps created from bits, wxImages, Xpms
  94     //
  95 } // end of wxBitmap::Init
  96
  97 bool wxBitmap::CopyFromIconOrCursor(
  98   const wxGDIImage&                 rIcon
  99 )
 100 {
 101     HPOINTER                        hIcon = (HPOINTER)rIcon.GetHandle();
 102     POINTERINFO                     SIconInfo;
 103
 104     if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
 105     {
 106         wxLogLastError(wxT("WinQueryPointerInfo"));
 107         return FALSE;
 108     }
 109     wxBitmapRefData*                pRefData = new wxBitmapRefData;
 110
 111     m_refData = pRefData;
 112
 113     int                             nWidth = rIcon.GetWidth();
 114     int                             nHeight = rIcon.GetHeight();
 115
 116     pRefData->m_nWidth  = nWidth;
 117     pRefData->m_nHeight = nHeight;
 118     pRefData->m_nDepth  = wxDisplayDepth();
 119
 120     pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
 121
 122     wxMask*                         pMask = new wxMask(SIconInfo.hbmPointer);
 123
 124     pMask->SetMaskBitmap(GetHBITMAP());
 125     SetMask(pMask);
 126
 127     return(TRUE);
 128 } // end of wxBitmap::CopyFromIconOrCursor
 129
 130 bool wxBitmap::CopyFromCursor(
 131   const wxCursor&                   rCursor
 132 )
 133 {
 134     UnRef();
 135
 136     if (!rCursor.Ok())
 137         return(FALSE);
 138     return(CopyFromIconOrCursor(rCursor));
 139 } // end of wxBitmap::CopyFromCursor
 140
 141 bool wxBitmap::CopyFromIcon(
 142   const wxIcon&                     rIcon
 143 )
 144 {
 145     UnRef();
 146
 147     if (!rIcon.Ok())
 148         return(FALSE);
 149
 150     return CopyFromIconOrCursor(rIcon);
 151 } // end of wxBitmap::CopyFromIcon
 152
 153 wxBitmap::~wxBitmap()
 154 {
 155 } // end of wxBitmap::~wxBitmap
 156
 157 wxBitmap::wxBitmap(
 158   const char                        zBits[]
 159 , int                               nWidth
 160 , int                               nHeight
 161 , int                               nDepth
 162 )
 163 {
 164     Init();
 165
 166     wxBitmapRefData*                pRefData = new wxBitmapRefData;
 167     BITMAPINFOHEADER2               vHeader;
 168     BITMAPINFO2                     vInfo;
 169     HDC                             hDc;
 170     HPS                             hPs;
 171     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 172     SIZEL                           vSize = {0, 0};
 173     char*                           pzData;
 174
 175     wxASSERT(vHabmain != NULL);
 176
 177     m_refData = pRefData;
 178
 179     pRefData->m_nWidth        = nWidth;
 180     pRefData->m_nHeight       = nHeight;
 181     pRefData->m_nDepth        = nDepth;
 182     pRefData->m_nNumColors    = 0;
 183     pRefData->m_pSelectedInto = NULL;
 184
 185     hDc   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
 186     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
 187     if (hPs == 0)
 188     {
 189         wxLogLastError("GpiCreatePS Failure");
 190     }
 191
 192     if (nDepth == 1)
 193     {
 194         //
 195         // We assume that it is in XBM format which is not quite the same as
 196         // the format CreateBitmap() wants because the order of bytes in the
 197         // line is inversed!
 198         //
 199         const size_t                nBytesPerLine = (nWidth + 7) / 8;
 200         const size_t                nPadding = nBytesPerLine % 2;
 201         const size_t                nLen = nHeight * (nPadding + nBytesPerLine);
 202         const char*                 pzSrc = zBits;
 203         int                         nRows;
 204         size_t                      nCols;
 205
 206         pzData = (char *)malloc(nLen);
 207
 208         char*                       pzDst = pzData;
 209
 210         for (nRows = 0; nRows < nHeight; nRows++)
 211         {
 212             for (nCols = 0; nCols < nBytesPerLine; nCols++)
 213             {
 214                 unsigned char       ucVal = *pzSrc++;
 215                 unsigned char       ucReversed = 0;
 216                 int                 nBits;
 217
 218                 for (nBits = 0; nBits < 8; nBits++)
 219                 {
 220                     ucReversed <<= 1;
 221                     ucReversed |= (ucVal & 0x01);
 222                     ucVal >>= 1;
 223                 }
 224                 *pzDst++ = ucReversed;
 225             }
 226             if (nPadding)
 227                 *pzDst++ = 0;
 228         }
 229     }
 230     else
 231     {
 232         //
 233         // Bits should already be in Windows standard format
 234         //
 235         pzData = (char *)zBits;    // const_cast is harmless
 236     }
 237
 238     if (nDepth > 24)
 239         nDepth = 24; // MAX supported in PM
 240     memset(&vHeader, '\0', 16);
 241     vHeader.cbFix           = 16;
 242     vHeader.cx              = (USHORT)nWidth;
 243     vHeader.cy              = (USHORT)nHeight;
 244     vHeader.cPlanes         = 1L;
 245     vHeader.cBitCount       = nDepth;
 246     vHeader.usReserved      = 0;
 247
 248     memset(&vInfo, '\0', 16);
 249     vInfo.cbFix           = 16;
 250     vInfo.cx              = (USHORT)nWidth;
 251     vInfo.cy              = (USHORT)nHeight;
 252     vInfo.cPlanes         = 1L;
 253     vInfo.cBitCount       = nDepth;
 254
 255     HBITMAP                         hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
 256
 257     if (!hBmp)
 258     {
 259         wxLogLastError("CreateBitmap");
 260     }
 261     ::GpiDestroyPS(hPs);
 262     ::DevCloseDC(hDc);
 263     SetHBITMAP((WXHBITMAP)hBmp);
 264 } // end of wxBitmap::wxBitmap
 265
 266 wxBitmap::wxBitmap(
 267   int                               nW
 268 , int                               nH
 269 , int                               nD
 270 )
 271 {
 272     Init();
 273     (void)Create( nW
 274                  ,nH
 275                  ,nD
 276                 );
 277 } // end of wxBitmap::wxBitmap
 278
 279 wxBitmap::wxBitmap(
 280   void*                             pData
 281 , long                              lType
 282 , int                               nWidth
 283 , int                               nHeight
 284 , int                               nDepth
 285 )
 286 {
 287     Init();
 288
 289     (void)Create( pData
 290                  ,lType
 291                  ,nWidth
 292                  ,nHeight
 293                  ,nDepth
 294                 );
 295 } // end of wxBitmap::wxBitmap
 296
 297 wxBitmap::wxBitmap(
 298   int                               nId
 299 , long                              lType
 300 )
 301 {
 302     Init();
 303     LoadFile( nId
 304              ,(int)lType
 305             );
 306     SetId(nId);
 307 } // end of wxBitmap::wxBitmap
 308
 309 bool wxBitmap::Create(
 310   int                               nW
 311 , int                               nH
 312 , int                               nD
 313 )
 314 {
 315     HBITMAP                         hBmp;
 316     BITMAPINFOHEADER2               vHeader;
 317
 318     wxASSERT(vHabmain != NULL);
 319     UnRef();
 320     m_refData = new wxBitmapRefData;
 321     GetBitmapData()->m_nWidth = nW;
 322     GetBitmapData()->m_nHeight = nH;
 323     GetBitmapData()->m_nDepth = nD;
 324
 325     //
 326     // Xpms and bitmaps from other images can also be mono's, but only
 327     // mono's need help changing their colors with MemDC changes
 328     //
 329     if (nD > 0)
 330     {
 331         DEVOPENSTRUC                vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 332         SIZEL                       vSize = {0, 0};
 333         HDC                         hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
 334         HPS                         hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 335
 336         if (nD == 1)
 337             m_bIsMono = TRUE;
 338         memset(&vHeader, '\0', 16);
 339         vHeader.cbFix     =  16;
 340         vHeader.cx        = nW;
 341         vHeader.cy        = nH;
 342         vHeader.cPlanes   = 1;
 343         vHeader.cBitCount = 24; //nD;
 344
 345         hBmp = ::GpiCreateBitmap( hPS
 346                                  ,&vHeader
 347                                  ,0L
 348                                  ,NULL
 349                                  ,NULL
 350                                 );
 351         ::GpiDestroyPS(hPS);
 352         ::DevCloseDC(hDC);
 353     }
 354     else
 355     {
 356         HPS                             hPSScreen;
 357         HDC                             hDCScreen;
 358         LONG                            lBitCount;
 359
 360         hPSScreen = ::WinGetScreenPS(HWND_DESKTOP);
 361         hDCScreen = ::GpiQueryDevice(hPSScreen);
 362         ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 363
 364         if (lBitCount > 24)
 365             lBitCount = 24;
 366
 367         memset(&vHeader, '\0', 16);
 368         vHeader.cbFix     =  16;
 369         vHeader.cx        = nW;
 370         vHeader.cy        = nH;
 371         vHeader.cPlanes   = 1;
 372         vHeader.cBitCount = lBitCount;
 373
 374         hBmp = ::GpiCreateBitmap( hPSScreen
 375                                  ,&vHeader
 376                                  ,0L
 377                                  ,NULL
 378                                  ,NULL
 379                                 );
 380
 381         GetBitmapData()->m_nDepth = wxDisplayDepth();
 382         ::WinReleasePS(hPSScreen);
 383     }
 384     SetHBITMAP((WXHBITMAP)hBmp);
 385
 386     return Ok();
 387 } // end of wxBitmap::Create
 388
 389 bool wxBitmap::CreateFromXpm(
 390   const char**                      ppData
 391 )
 392 {
 393 #if wxUSE_IMAGE && wxUSE_XPM
 394     Init();
 395
 396     wxCHECK_MSG(ppData != NULL, FALSE, wxT("invalid bitmap data"))
 397
 398     wxXPMDecoder                    vDecoder;
 399     wxImage                         vImg = vDecoder.ReadData(ppData);
 400
 401     wxCHECK_MSG(vImg.Ok(), FALSE, wxT("invalid bitmap data"))
 402
 403     *this = wxBitmap(vImg);
 404     return TRUE;
 405 #else
 406     return FALSE;
 407 #endif
 408 } // end of wxBitmap::CreateFromXpm
 409
 410 bool wxBitmap::LoadFile(
 411   int                               nId
 412 , long                              lType
 413 )
 414 {
 415     HPS                             hPs = NULLHANDLE;
 416
 417     UnRef();
 418
 419     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 420                                                              ,wxBitmapHandler
 421                                                             );
 422
 423     if (pHandler)
 424     {
 425         m_refData = new wxBitmapRefData;
 426
 427         return(pHandler->LoadFile( this
 428                                   ,nId
 429                                   ,lType
 430                                   , -1
 431                                   , -1
 432                                  ));
 433     }
 434     else
 435     {
 436         return(FALSE);
 437     }
 438 } // end of wxBitmap::LoadFile
 439
 440 bool wxBitmap::Create(
 441   void*                             pData
 442 , long                              lType
 443 , int                               nWidth
 444 , int                               nHeight
 445 , int                               nDepth
 446 )
 447 {
 448     UnRef();
 449
 450     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 451                                                              ,wxBitmapHandler
 452                                                             );
 453
 454     if (!pHandler)
 455     {
 456         wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
 457                        "type %d defined."), lType);
 458
 459         return(FALSE);
 460     }
 461
 462     m_refData = new wxBitmapRefData;
 463
 464     return(pHandler->Create( this
 465                             ,pData
 466                             ,lType
 467                             ,nWidth
 468                             ,nHeight
 469                             ,nDepth
 470                            ));
 471 } // end of wxBitmap::Create
 472
 473 bool wxBitmap::SaveFile(
 474   const wxString&                   rFilename
 475 , int                               lType
 476 , const wxPalette*                  pPalette
 477 )
 478 {
 479     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 480                                                              ,wxBitmapHandler
 481                                                             );
 482
 483     if (pHandler)
 484     {
 485         return pHandler->SaveFile( this
 486                                   ,rFilename
 487                                   ,lType
 488                                   ,pPalette
 489                                  );
 490     }
 491     else
 492     {
 493         // FIXME what about palette? shouldn't we use it?
 494         wxImage                     vImage = ConvertToImage();
 495
 496         if (!vImage.Ok())
 497             return(FALSE);
 498
 499         return(vImage.SaveFile( rFilename
 500                                ,lType
 501                               ));
 502     }
 503 } // end of wxBitmap::SaveFile
 504
 505
 506 // ----------------------------------------------------------------------------
 507 // wxImage-wxBitmap conversion
 508 // ----------------------------------------------------------------------------
 509
 510 bool wxBitmap::CreateFromImage (
 511   const wxImage&                    rImage
 512 , int                               nDepth
 513 )
 514 {
 515     wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
 516     m_refData = new wxBitmapRefData();
 517
 518     int                             nSizeLimit = 1024 * 768 * 3;
 519     int                             nWidth = rImage.GetWidth();
 520     int                             nBmpHeight = rImage.GetHeight();
 521     int                             nBytePerLine = nWidth * 3;
 522     int                             nSizeDWORD = sizeof(DWORD);
 523     int                             nLineBoundary = nBytePerLine % nSizeDWORD;
 524     int                             nPadding = 0;
 525
 526     if (nLineBoundary > 0)
 527     {
 528         nPadding = nSizeDWORD - nLineBoundary;
 529         nBytePerLine += nPadding;
 530     }
 531
 532     //
 533     // Calc the number of DIBs and heights of DIBs
 534     //
 535     int                             nNumDIB = 1;
 536     int                             nHRemain = 0;
 537     int                             nHeight = nSizeLimit / nBytePerLine;
 538
 539     if (nHeight >= nBmpHeight)
 540         nHeight = nBmpHeight;
 541     else
 542     {
 543         nNumDIB  = nBmpHeight / nHeight;
 544         nHRemain = nBmpHeight % nHeight;
 545         if (nHRemain > 0)
 546             nNumDIB++;
 547     }
 548
 549     //
 550     // Set bitmap parameters
 551     //
 552     wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
 553     SetWidth(nWidth);
 554     SetHeight(nBmpHeight);
 555     if (nDepth == 1)
 556         m_bIsMono = TRUE;
 557     else
 558         m_bIsMono = FALSE;
 559     if (nDepth == -1)
 560         nDepth = wxDisplayDepth();
 561     SetDepth(nDepth);
 562
 563 #if wxUSE_PALETTE
 564     //
 565     // Copy the palette from the source image
 566     //
 567     SetPalette(rImage.GetPalette());
 568 #endif // wxUSE_PALETTE
 569
 570     //
 571     // Create a DIB header
 572     //
 573     BITMAPINFOHEADER2               vHeader;
 574     BITMAPINFO2                     vInfo;
 575
 576     //
 577     // Fill in the DIB header
 578     //
 579     memset(&vHeader, '\0', 16);
 580     vHeader.cbFix           = 16;
 581     vHeader.cx              = (ULONG)nWidth;
 582     vHeader.cy              = (ULONG)nHeight;
 583     vHeader.cPlanes         = 1L;
 584     vHeader.cBitCount       = 24;
 585
 586     //
 587     // Memory for DIB data
 588     //
 589     unsigned char*                  pucBits;
 590
 591     pucBits = (unsigned char *)malloc(nBytePerLine * nHeight);
 592     if(!pucBits)
 593     {
 594         wxFAIL_MSG(wxT("could not allocate memory for DIB"));
 595         return FALSE;
 596     }
 597     memset(pucBits, '\0', (nBytePerLine * nHeight));
 598
 599     //
 600     // Create and set the device-dependent bitmap
 601     //
 602     DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 603     SIZEL                           vSize = {0, 0};
 604     HDC                             hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
 605     HPS                             hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 606     LONG                            lScans;
 607     HDC                             hDCScreen = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
 608     HPS                             hPSScreen;
 609     HBITMAP                         hBmp;
 610     HBITMAP                         hBmpOld;
 611
 612     memset(&vInfo, '\0', 16);
 613     vInfo.cbFix           = 16;
 614     vInfo.cx              = (ULONG)nWidth;
 615     vInfo.cy              = (ULONG)nHeight;
 616     vInfo.cPlanes         = 1;
 617     vInfo.cBitCount       = 24; // Set to desired count going in
 618
 619     hBmp = ::GpiCreateBitmap( hPS
 620                              ,&vHeader
 621                              ,0L
 622                              ,NULL
 623                              ,NULL
 624                             );
 625 #if wxUSE_PALETTE
 626     HPAL                            hOldPalette = NULLHANDLE;
 627     if (rImage.GetPalette().Ok())
 628     {
 629         hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE());
 630     }
 631 #endif // wxUSE_PALETTE
 632
 633     //
 634     // Copy image data into DIB data and then into DDB (in a loop)
 635     //
 636     unsigned char*                  pData = rImage.GetData();
 637     int                             i;
 638     int                             j;
 639     int                             n;
 640     int                             nOrigin = 0;
 641     unsigned char*                  ptdata = pData;
 642     unsigned char*                  ptbits;
 643
 644     if ((hBmpOld = ::GpiSetBitmap(hPS, hBmp)) == HBM_ERROR)
 645     {
 646         ERRORID                 vError;
 647         wxString                sError;
 648
 649         vError = ::WinGetLastError(vHabmain);
 650         sError = wxPMErrorToStr(vError);
 651     }
 652     for (n = 0; n < nNumDIB; n++)
 653     {
 654         if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
 655         {
 656             //
 657             // Redefine height and size of the (possibly) last smaller DIB
 658             // memory is not reallocated
 659             //
 660             nHeight         = nHRemain;
 661             vHeader.cy      = (DWORD)(nHeight);
 662             vHeader.cbImage = nBytePerLine * nHeight;
 663         }
 664         ptbits = pucBits;
 665         for (j = 0; j < nHeight; j++)
 666         {
 667             for (i = 0; i < nWidth; i++)
 668             {
 669                 *(ptbits++) = *(ptdata + 2);
 670                 *(ptbits++) = *(ptdata + 1);
 671                 *(ptbits++) = *(ptdata);
 672                 ptdata += 3;
 673             }
 674             for (i = 0; i < nPadding; i++)
 675                 *(ptbits++) = 0;
 676         }
 677
 678         //
 679         // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
 680         // in combination with setting the bits into the selected bitmap
 681         //
 682         if ((lScans = ::GpiSetBitmapBits( hPS
 683                                          ,0             // Start at the bottom
 684                                          ,(LONG)nHeight // One line per scan
 685                                          ,(PBYTE)pucBits
 686                                          ,&vInfo
 687                                        )) == GPI_ALTERROR)
 688         {
 689             ERRORID                 vError;
 690             wxString                sError;
 691
 692             vError = ::WinGetLastError(vHabmain);
 693             sError = wxPMErrorToStr(vError);
 694         }
 695         hPSScreen = ::GpiCreatePS( vHabmain
 696                                   ,hDCScreen
 697                                   ,&vSize
 698                                   ,PU_PELS | GPIA_ASSOC
 699                                  );
 700
 701         POINTL                      vPoint[4] = { {0, nOrigin},
 702                                                   {nWidth, nHeight},
 703                                                   {0, 0}, {nWidth, nHeight}
 704                                                 };
 705
 706
 707         ::GpiBitBlt( hPSScreen
 708                     ,hPS
 709                     ,4
 710                     ,vPoint
 711                     ,ROP_SRCCOPY
 712                     ,BBO_IGNORE
 713                    );
 714         ::GpiDestroyPS(hPSScreen);
 715         nOrigin += nHeight;
 716     }
 717     SetHBITMAP((WXHBITMAP)hBmp);
 718 #if wxUSE_PALETTE
 719     if (hOldPalette)
 720         ::GpiSelectPalette(hPS, hOldPalette);
 721 #endif // wxUSE_PALETTE
 722
 723     //
 724     // Similarly, created an mono-bitmap for the possible mask
 725     //
 726     if (rImage.HasMask())
 727     {
 728         vHeader.cbFix     = 16;
 729         vHeader.cx        = nWidth;
 730         vHeader.cy        = nHeight;
 731         vHeader.cPlanes   = 1;
 732         vHeader.cBitCount = 24;
 733         hBmp = ::GpiCreateBitmap( hPS
 734                                  ,&vHeader
 735                                  ,0L
 736                                  ,NULL
 737                                  ,NULL
 738                                 );
 739         hBmpOld = ::GpiSetBitmap(hPS, hBmp);
 740         if (nNumDIB == 1)
 741             nHeight = nBmpHeight;
 742         else
 743             nHeight = nSizeLimit / nBytePerLine;
 744         vHeader.cy = (DWORD)(nHeight);
 745         nOrigin = 0;
 746
 747         unsigned char               cRed   = rImage.GetMaskRed();
 748         unsigned char               cGreen = rImage.GetMaskGreen();
 749         unsigned char               cBlue  = rImage.GetMaskBlue();
 750         unsigned char               cZero = 0;
 751         unsigned char               cOne = 255;
 752
 753         ptdata = pData;
 754         for (n = 0; n < nNumDIB; n++)
 755         {
 756             if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
 757             {
 758                 //
 759                 // Redefine height and size of the (possibly) last smaller DIB
 760                 // memory is not reallocated
 761                 //
 762                 nHeight         = nHRemain;
 763                 vHeader.cy      = (DWORD)(nHeight);
 764                 vHeader.cbImage = nBytePerLine * nHeight;
 765             }
 766             ptbits = pucBits;
 767             for (int j = 0; j < nHeight; j++)
 768             {
 769                 for (i = 0; i < nWidth; i++)
 770                 {
 771                     unsigned char cRedImage   = (*(ptdata++)) ;
 772                     unsigned char cGreenImage = (*(ptdata++)) ;
 773                     unsigned char cBlueImage  = (*(ptdata++)) ;
 774
 775                     if ((cRedImage != cRed) || (cGreenImage != cGreen) || (cBlueImage != cBlue))
 776                     {
 777                         *(ptbits++) = cOne;
 778                         *(ptbits++) = cOne;
 779                         *(ptbits++) = cOne;
 780                     }
 781                     else
 782                     {
 783                         *(ptbits++) = cZero;
 784                         *(ptbits++) = cZero;
 785                         *(ptbits++) = cZero;
 786                     }
 787                 }
 788                 for (i = 0; i < nPadding; i++)
 789                     *(ptbits++) = cZero;
 790             }
 791             lScans = ::GpiSetBitmapBits( hPS
 792                                         ,0              // Start at the bottom
 793                                         ,(LONG)nHeight // One line per scan
 794                                         ,(PBYTE)pucBits
 795                                         ,&vInfo
 796                                        );
 797             hPSScreen = ::GpiCreatePS( vHabmain
 798                                       ,hDCScreen
 799                                       ,&vSize
 800                                       ,PU_PELS | GPIA_ASSOC
 801                                      );
 802             POINTL vPoint2[4] = { {0, nOrigin},
 803                                   {nWidth, nHeight},
 804                                   {0, 0}, {nWidth, nHeight}
 805                                 };
 806             ::GpiBitBlt( hPSScreen
 807                         ,hPS
 808                         ,4
 809                         ,vPoint2
 810                         ,ROP_SRCCOPY
 811                         ,BBO_IGNORE
 812                    );
 813             ::GpiDestroyPS(hPSScreen);
 814             nOrigin += nHeight;
 815         }
 816
 817         //
 818         // Create a wxMask object
 819         //
 820         wxMask*                     pMask = new wxMask();
 821
 822         pMask->SetMaskBitmap((WXHBITMAP)hBmp);
 823         SetMask(pMask);
 824         hBmpOld = ::GpiSetBitmap(hPS, hBmpOld);
 825     }
 826
 827     //
 828     // Free allocated resources
 829     //
 830     ::GpiSetBitmap(hPS, NULLHANDLE);
 831     ::GpiDestroyPS(hPS);
 832     ::DevCloseDC(hDCScreen);
 833     ::DevCloseDC(hDC);
 834     free(pucBits);
 835     return TRUE;
 836 } // end of wxBitmap::CreateFromImage
 837
 838 wxImage wxBitmap::ConvertToImage() const
 839 {
 840     wxImage                         vImage;
 841     wxDC*                           pDC;
 842
 843     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 844
 845     //
 846     // Create an wxImage object
 847     //
 848     int                             nWidth        = GetWidth();
 849     int                             nHeight       = GetHeight();
 850     int                             nDevWidth;
 851     int                             nDevHeight;
 852     int                             nBytePerLine  = nWidth * 3;
 853     int                             nSizeDWORD    = sizeof(DWORD);
 854     int                             nLineBoundary = nBytePerLine % nSizeDWORD;
 855     int                             nPadding = 0;
 856     unsigned char*                  pData;
 857     unsigned char*                  lpBits;
 858     long                            lScans;
 859     BITMAPINFOHEADER2               vDIBh;
 860     BITMAPINFO2                     vDIBInfo;
 861     HPS                             hPSMem;
 862     HPS                             hPS;
 863     HBITMAP                         hBitmap;
 864     HBITMAP                         hOldBitmap;
 865     DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 866     SIZEL                           vSizlPage = {0,0};
 867     HDC                             hDCMem;
 868
 869     vImage.Create( nWidth
 870                   ,nHeight
 871                  );
 872     pData = vImage.GetData();
 873     if(!pData)
 874     {
 875         wxFAIL_MSG( wxT("could not allocate data for image") );
 876         return wxNullImage;
 877     }
 878     if(nLineBoundary > 0)
 879     {
 880         nPadding     = nSizeDWORD - nLineBoundary;
 881         nBytePerLine += nPadding;
 882     }
 883     wxDisplaySize( &nDevWidth
 884                   ,&nDevHeight
 885                  );
 886     //
 887     // Create and fill a DIB header
 888     //
 889     memset(&vDIBh, '\0', 16);
 890     vDIBh.cbFix     =  16;
 891     vDIBh.cx        = nWidth;
 892     vDIBh.cy        = nHeight;
 893     vDIBh.cPlanes   = 1;
 894     vDIBh.cBitCount = 24;
 895
 896     memset(&vDIBInfo, '\0', 16);
 897     vDIBInfo.cbFix           = 16;
 898     vDIBInfo.cx              = nWidth;
 899     vDIBInfo.cy              = nHeight;
 900     vDIBInfo.cPlanes         = 1;
 901     vDIBInfo.cBitCount       = 24;
 902
 903     lpBits = (unsigned char *)malloc(nBytePerLine * nHeight);
 904     if (!lpBits)
 905     {
 906         wxFAIL_MSG(wxT("could not allocate data for DIB"));
 907         free(pData);
 908         return wxNullImage;
 909     }
 910     memset(lpBits, '\0', (nBytePerLine * nHeight));
 911     hBitmap = (HBITMAP)GetHBITMAP();
 912
 913     //
 914     // May already be selected into a PS
 915     //
 916     if ((pDC = GetSelectedInto()) != NULL)
 917     {
 918         hPSMem = pDC->GetHPS();
 919     }
 920     else
 921     {
 922         hDCMem = ::DevOpenDC( vHabmain
 923                              ,OD_MEMORY
 924                              ,"*"
 925                              ,5L
 926                              ,(PDEVOPENDATA)&vDop
 927                              ,NULLHANDLE
 928                             );
 929         hPSMem = ::GpiCreatePS( vHabmain
 930                                ,hDCMem
 931                                ,&vSizlPage
 932                                ,PU_PELS | GPIA_ASSOC
 933                               );
 934     }
 935     if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
 936     {
 937         ERRORID                 vError;
 938         wxString                sError;
 939
 940         vError = ::WinGetLastError(vHabmain);
 941         sError = wxPMErrorToStr(vError);
 942     }
 943
 944     //
 945     // Copy data from the device-dependent bitmap to the DIB
 946     //
 947     if ((lScans = ::GpiQueryBitmapBits( hPSMem
 948                                        ,0L
 949                                        ,(LONG)nHeight
 950                                        ,(PBYTE)lpBits
 951                                        ,&vDIBInfo
 952                                       )) == GPI_ALTERROR)
 953     {
 954         ERRORID                     vError;
 955         wxString                    sError;
 956
 957         vError = ::WinGetLastError(vHabmain);
 958         sError = wxPMErrorToStr(vError);
 959     }
 960
 961     //
 962     // Copy DIB data into the wxImage object
 963     //
 964     int                             i;
 965     int                             j;
 966     unsigned char*                  ptdata = pData;
 967     unsigned char*                  ptbits = lpBits;
 968
 969     for (i = 0; i < nHeight; i++)
 970     {
 971         for (j = 0; j < nWidth; j++)
 972         {
 973             *(ptdata++) = *(ptbits+2);
 974             *(ptdata++) = *(ptbits+1);
 975             *(ptdata++) = *(ptbits  );
 976             ptbits += 3;
 977         }
 978         ptbits += nPadding;
 979     }
 980     if ((pDC = GetSelectedInto()) == NULL)
 981     {
 982         ::GpiSetBitmap(hPSMem, NULLHANDLE);
 983         ::GpiDestroyPS(hPSMem);
 984         ::DevCloseDC(hDCMem);
 985     }
 986
 987     //
 988     // Similarly, set data according to the possible mask bitmap
 989     //
 990     if (GetMask() && GetMask()->GetMaskBitmap())
 991     {
 992         hBitmap = (HBITMAP)GetMask()->GetMaskBitmap();
 993
 994         //
 995         // Memory DC/PS created, color set, data copied, and memory DC/PS deleted
 996         //
 997         HDC                        hMemDC = ::DevOpenDC( vHabmain
 998                                                         ,OD_MEMORY
 999                                                         ,"*"
1000                                                         ,5L
1001                                                         ,(PDEVOPENDATA)&vDop
1002                                                         ,NULLHANDLE
1003                                                        );
1004         HPS                         hMemPS = ::GpiCreatePS( vHabmain
1005                                                            ,hMemDC
1006                                                            ,&vSizlPage
1007                                                            ,PU_PELS | GPIA_ASSOC
1008                                                           );
1009         ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0));
1010         ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) );
1011         ::GpiSetBitmap(hMemPS, hBitmap);
1012         ::GpiQueryBitmapBits( hPSMem
1013                              ,0L
1014                              ,(LONG)nHeight
1015                              ,(PBYTE)lpBits
1016                              ,&vDIBInfo
1017                             );
1018         ::GpiSetBitmap(hMemPS, NULLHANDLE);
1019         ::GpiDestroyPS(hMemPS);
1020         ::DevCloseDC(hMemDC);
1021
1022         //
1023         // Background color set to RGB(16,16,16) in consistent with wxGTK
1024         //
1025         unsigned char               ucRed = 16;
1026         unsigned char               ucGreen = 16;
1027         unsigned char               ucBlue = 16;
1028
1029         ptdata = pData;
1030         ptbits = lpBits;
1031         for (i = 0; i < nHeight; i++)
1032         {
1033             for (j = 0; j < nWidth; j++)
1034             {
1035                 if (*ptbits != 0)
1036                     ptdata += 3;
1037                 else
1038                 {
1039                     *(ptdata++)  = ucRed;
1040                     *(ptdata++)  = ucGreen;
1041                     *(ptdata++)  = ucBlue;
1042                 }
1043                 ptbits += 3;
1044             }
1045             ptbits += nPadding;
1046         }
1047         vImage.SetMaskColour( ucRed
1048                              ,ucGreen
1049                              ,ucBlue
1050                             );
1051         vImage.SetMask(TRUE);
1052     }
1053     else
1054     {
1055         vImage.SetMask(FALSE);
1056     }
1057
1058     //
1059     // Free allocated resources
1060     //
1061     free(lpBits);
1062     return vImage;
1063 } // end of wxBitmap::ConvertToImage
1064
1065 // ----------------------------------------------------------------------------
1066 // sub bitmap extraction
1067 // ----------------------------------------------------------------------------
1068
1069 wxBitmap wxBitmap::GetSubBitmap(
1070   const wxRect&                     rRect
1071 ) const
1072 {
1073     wxCHECK_MSG( Ok() &&
1074                  (rRect.x >= 0) && (rRect.y >= 0) &&
1075                  (rRect.x + rRect.width <= GetWidth()) &&
1076                  (rRect.y + rRect.height <= GetHeight()),
1077                  wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
1078
1079     wxBitmap                        vRet( rRect.width
1080                                          ,rRect.height
1081                                          ,GetDepth()
1082                                         );
1083     wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") );
1084
1085
1086     //
1087     // Copy bitmap data
1088     //
1089     SIZEL                           vSize = {0, 0};
1090     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1091     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1092     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1093     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1094     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1095     POINTL                          vPoint[4] = { {0, 0}, {rRect.width, rRect.height},
1096                                                   {rRect.x, rRect.y},
1097                                                   {rRect.x + rRect.width, rRect.y + rRect.height}
1098                                                 };
1099
1100     ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
1101     ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
1102     ::GpiBitBlt( hPSDst
1103                 ,hPSSrc
1104                 ,4L
1105                 ,vPoint
1106                 ,ROP_SRCCOPY
1107                 ,BBO_IGNORE
1108                );
1109
1110     //
1111     // Copy mask if there is one
1112     //
1113     if (GetMask())
1114     {
1115         BITMAPINFOHEADER2           vBmih;
1116
1117         memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1118         vBmih.cbFix     = sizeof(BITMAPINFOHEADER2);
1119         vBmih.cx        = rRect.width;
1120         vBmih.cy        = rRect.height;
1121         vBmih.cPlanes   = 1;
1122         vBmih.cBitCount = 24;
1123
1124         HBITMAP                     hBmpMask = ::GpiCreateBitmap( hPSDst
1125                                                                  ,&vBmih
1126                                                                  ,0L
1127                                                                  ,NULL
1128                                                                  ,NULL
1129                                                                 );
1130
1131         ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
1132         ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
1133
1134         ::GpiSetBitmap(hPSSrc, (HBITMAP) GetMask()->GetMaskBitmap());
1135         ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpMask);
1136         ::GpiBitBlt( hPSDst
1137                     ,hPSSrc
1138                     ,4L
1139                     ,vPoint
1140                     ,ROP_SRCCOPY
1141                     ,BBO_IGNORE
1142                    );
1143
1144         wxMask*                     pMask = new wxMask((WXHBITMAP)hBmpMask);
1145         vRet.SetMask(pMask);
1146     }
1147
1148     ::GpiSetBitmap(hPSSrc, NULL);
1149     ::GpiSetBitmap(hPSDst, NULL);
1150     ::GpiDestroyPS(hPSSrc);
1151     ::GpiDestroyPS(hPSDst);
1152     ::DevCloseDC(hDCSrc);
1153     ::DevCloseDC(hDCDst);
1154     return vRet;
1155 } // end of wxBitmap::GetSubBitmap
1156
1157 // ----------------------------------------------------------------------------
1158 // wxBitmap accessors
1159 // ----------------------------------------------------------------------------
1160
1161 void wxBitmap::SetQuality(
1162   int                               nQ
1163 )
1164 {
1165     EnsureHasData();
1166
1167     GetBitmapData()->m_nQuality = nQ;
1168 } // end of wxBitmap::SetQuality
1169
1170 void wxBitmap::SetPalette(
1171   const wxPalette&                  rPalette
1172 )
1173 {
1174     EnsureHasData();
1175
1176     GetBitmapData()->m_vBitmapPalette = rPalette;
1177 } // end of wxBitmap::SetPalette
1178
1179 void wxBitmap::SetMask(
1180   wxMask*                           pMask
1181 )
1182 {
1183     EnsureHasData();
1184
1185     GetBitmapData()->m_pBitmapMask = pMask;
1186 } // end of wxBitmap::SetMask
1187
1188 wxBitmap wxBitmap::GetBitmapForDC(
1189   wxDC&                             rDc
1190 ) const
1191 {
1192     return(*this);
1193 } // end of wxBitmap::GetBitmapForDC
1194
1195 // ----------------------------------------------------------------------------
1196 // wxMask
1197 // ----------------------------------------------------------------------------
1198
1199 wxMask::wxMask()
1200 {
1201     m_hMaskBitmap = 0;
1202 } // end of wxMask::wxMask
1203
1204 // Construct a mask from a bitmap and a colour indicating
1205 // the transparent area
1206 wxMask::wxMask(
1207   const wxBitmap&                   rBitmap
1208 , const wxColour&                   rColour
1209 )
1210 {
1211     m_hMaskBitmap = 0;
1212     Create( rBitmap
1213            ,rColour
1214           );
1215 } // end of wxMask::wxMask
1216
1217 // Construct a mask from a bitmap and a palette index indicating
1218 // the transparent area
1219 wxMask::wxMask(
1220   const wxBitmap&                   rBitmap
1221 , int                               nPaletteIndex
1222 )
1223 {
1224     m_hMaskBitmap = 0;
1225     Create( rBitmap
1226            ,nPaletteIndex
1227           );
1228 } // end of wxMask::wxMask
1229
1230 // Construct a mask from a mono bitmap (copies the bitmap).
1231 wxMask::wxMask(
1232   const wxBitmap&                   rBitmap
1233 )
1234 {
1235     m_hMaskBitmap = 0;
1236     Create(rBitmap);
1237 } // end of wxMask::wxMask
1238
1239 wxMask::~wxMask()
1240 {
1241     if (m_hMaskBitmap)
1242         ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
1243 } // end of wxMask::~wxMask
1244
1245 // Create a mask from a mono bitmap (copies the bitmap).
1246 bool wxMask::Create(
1247   const wxBitmap&                   rBitmap
1248 )
1249 {
1250     BITMAPINFOHEADER2               vBmih;
1251     SIZEL                           vSize = {0, 0};
1252     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1253     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1254     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1255     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1256     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1257     POINTL                          vPoint[4] = { {0 ,0}, {rBitmap.GetWidth(), rBitmap.GetHeight()},
1258                                                   {0, 0}, {rBitmap.GetWidth(), rBitmap.GetHeight()}
1259                                                 };
1260
1261     if (m_hMaskBitmap)
1262     {
1263         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1264         m_hMaskBitmap = 0;
1265     }
1266     if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
1267     {
1268         return(FALSE);
1269     }
1270
1271     memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1272     vBmih.cbFix     =  sizeof(BITMAPINFOHEADER2);
1273     vBmih.cx        = rBitmap.GetWidth();
1274     vBmih.cy        = rBitmap.GetHeight();
1275     vBmih.cPlanes   = 1;
1276     vBmih.cBitCount = 24;
1277
1278     m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1279                                       ,&vBmih
1280                                       ,0L
1281                                       ,NULL
1282                                       ,NULL
1283                                      );
1284
1285     ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1286     ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1287     ::GpiBitBlt( hPSDst
1288                 ,hPSSrc
1289                 ,4L
1290                 ,vPoint
1291                 ,ROP_SRCCOPY
1292                 ,BBO_IGNORE
1293                );
1294
1295     ::GpiDestroyPS(hPSSrc);
1296     ::GpiDestroyPS(hPSDst);
1297     ::DevCloseDC(hDCSrc);
1298     ::DevCloseDC(hDCDst);
1299     return(TRUE);
1300 } // end of wxMask::Create
1301
1302 // Create a mask from a bitmap and a palette index indicating
1303 // the transparent area
1304 bool wxMask::Create(
1305   const wxBitmap&                   rBitmap
1306 , int                               nPaletteIndex
1307 )
1308 {
1309     if (m_hMaskBitmap)
1310     {
1311         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1312         m_hMaskBitmap = 0;
1313     }
1314     if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
1315     {
1316         unsigned char               cRed;
1317         unsigned char               cGreen;
1318         unsigned char               cBlue;
1319
1320         if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
1321                                          ,&cRed
1322                                          ,&cGreen
1323                                          ,&cBlue
1324                                         ))
1325         {
1326             wxColour                vTransparentColour( cRed
1327                                                        ,cGreen
1328                                                        ,cBlue
1329                                                       );
1330
1331             return (Create( rBitmap
1332                            ,vTransparentColour
1333                           ));
1334         }
1335     }
1336     return(FALSE);
1337 } // end of wxMask::Create
1338
1339 // Create a mask from a bitmap and a colour indicating
1340 // the transparent area
1341 bool wxMask::Create(
1342   const wxBitmap&                   rBitmap
1343 , const wxColour&                   rColour
1344 )
1345 {
1346     bool                            bOk = TRUE;
1347     COLORREF                        vMaskColour = OS2RGB( rColour.Red()
1348                                                          ,rColour.Green()
1349                                                          ,rColour.Blue()
1350                                                         );
1351     BITMAPINFOHEADER2               vBmih;
1352     SIZEL                           vSize = {0, 0};
1353     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
1354     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1355     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1356     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1357     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1358     POINTL                          vPoint[4] = { {0 ,0}, {rBitmap.GetWidth(), rBitmap.GetHeight()},
1359                                                   {0, 0}, {rBitmap.GetWidth(), rBitmap.GetHeight()}
1360                                                 };
1361
1362     if (m_hMaskBitmap)
1363     {
1364         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1365         m_hMaskBitmap = 0;
1366     }
1367     if (!rBitmap.Ok())
1368     {
1369         return(FALSE);
1370     }
1371
1372     //
1373     // Scan the bitmap for the transparent colour and set
1374     // the corresponding pixels in the mask to BLACK and
1375     // the rest to WHITE
1376     //
1377
1378     memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1379     vBmih.cbFix     =  sizeof(BITMAPINFOHEADER2);
1380     vBmih.cx        = rBitmap.GetWidth();
1381     vBmih.cy        = rBitmap.GetHeight();
1382     vBmih.cPlanes   = 1;
1383     vBmih.cBitCount = 1;
1384
1385     m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1386                                       ,&vBmih
1387                                       ,0L
1388                                       ,NULL
1389                                       ,NULL
1390                                      );
1391
1392     ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1393     ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1394
1395     //
1396     // This is not very efficient, but I can't think
1397     // of a better way of doing it
1398     //
1399     for (int w = 0; w < rBitmap.GetWidth(); w++)
1400     {
1401         for (int h = 0; h < rBitmap.GetHeight(); h++)
1402         {
1403             POINTL                  vPt = {w, h};
1404             COLORREF                vCol = (COLORREF)::GpiQueryPel(hPSSrc, &vPt);
1405             if (vCol == (COLORREF)CLR_NOINDEX)
1406             {
1407                 //
1408                 // Doesn't make sense to continue
1409                 //
1410                 bOk = FALSE;
1411                 break;
1412             }
1413
1414             if (vCol == vMaskColour)
1415             {
1416                 ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0));
1417                 ::GpiSetPel(hPSDst, &vPt);
1418             }
1419             else
1420             {
1421                 ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255));
1422                 ::GpiSetPel(hPSDst, &vPt);
1423             }
1424         }
1425     }
1426     ::GpiSetBitmap(hPSSrc, NULL);
1427     ::GpiSetBitmap(hPSDst, NULL);
1428     ::GpiDestroyPS(hPSSrc);
1429     ::GpiDestroyPS(hPSDst);
1430     ::DevCloseDC(hDCSrc);
1431     ::DevCloseDC(hDCDst);
1432     return(TRUE);
1433 } // end of wxMask::Create
1434
1435 // ----------------------------------------------------------------------------
1436 // wxBitmapHandler
1437 // ----------------------------------------------------------------------------
1438
1439 bool wxBitmapHandler::Create(
1440   wxGDIImage*                       pImage
1441 , void*                             pData
1442 , long                              lFlags
1443 , int                               nWidth
1444 , int                               nHeight
1445 , int                               nDepth
1446 )
1447 {
1448     wxBitmap*                       pBitmap = wxDynamicCast( pImage
1449                                                             ,wxBitmap
1450                                                            );
1451
1452     return(pBitmap ? Create( pBitmap
1453                             ,pData
1454                             ,nWidth
1455                             ,nHeight
1456                             ,nDepth
1457                            ) : FALSE);
1458 }
1459
1460 bool wxBitmapHandler::Load(
1461   wxGDIImage*                       pImage
1462 , int                               nId
1463 , long                              lFlags
1464 , int                               nWidth
1465 , int                               nHeight
1466 )
1467 {
1468     wxBitmap*                       pBitmap = wxDynamicCast( pImage
1469                                                             ,wxBitmap
1470                                                            );
1471
1472     return(pBitmap ? LoadFile( pBitmap
1473                               ,nId
1474                               ,lFlags
1475                               ,nWidth
1476                               ,nHeight
1477                              ) : FALSE);
1478 }
1479
1480 bool wxBitmapHandler::Save(
1481   wxGDIImage*                       pImage
1482 , const wxString&                   rName
1483 , int                               lType
1484 )
1485 {
1486     wxBitmap*                       pBitmap = wxDynamicCast( pImage
1487                                                             ,wxBitmap
1488                                                            );
1489
1490     return(pBitmap ? SaveFile( pBitmap
1491                               ,rName
1492                               ,lType
1493                              ) : FALSE);
1494 }
1495
1496 bool wxBitmapHandler::Create(
1497   wxBitmap*                         WXUNUSED(pBitmap)
1498 , void*                             WXUNUSED(pData)
1499 , long                              WXUNUSED(lType)
1500 , int                               WXUNUSED(nWidth)
1501 , int                               WXUNUSED(nHeight)
1502 , int                               WXUNUSED(nDepth)
1503 )
1504 {
1505     return(FALSE);
1506 }
1507
1508 bool wxBitmapHandler::LoadFile(
1509   wxBitmap*                         WXUNUSED(pBitmap)
1510 , int                               WXUNUSED(nId)
1511 , long                              WXUNUSED(lType)
1512 , int                               WXUNUSED(nDesiredWidth)
1513 , int                               WXUNUSED(nDesiredHeight)
1514 )
1515 {
1516     return(FALSE);
1517 }
1518
1519 bool wxBitmapHandler::SaveFile(
1520   wxBitmap*                         WXUNUSED(pBitmap)
1521 , const wxString&                   WXUNUSED(rName)
1522 , int                               WXUNUSED(nType)
1523 , const wxPalette*                  WXUNUSED(pPalette)
1524 )
1525 {
1526     return(FALSE);
1527 }
1528
1529 // ----------------------------------------------------------------------------
1530 // Utility functions
1531 // ----------------------------------------------------------------------------
1532 HBITMAP wxInvertMask(
1533   HBITMAP                           hBmpMask
1534 , int                               nWidth
1535 , int                               nHeight
1536 )
1537 {
1538     HBITMAP                         hBmpInvMask = 0;
1539
1540     wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") );
1541
1542     //
1543     // Get width/height from the bitmap if not given
1544     //
1545     if (!nWidth || !nHeight)
1546     {
1547         BITMAPINFOHEADER2           vBmhdr;
1548
1549         ::GpiQueryBitmapInfoHeader( hBmpMask
1550                                    ,&vBmhdr
1551                                   );
1552         nWidth  = (int)vBmhdr.cx;
1553         nHeight = (int)vBmhdr.cy;
1554     }
1555
1556     BITMAPINFOHEADER2               vBmih;
1557     SIZEL                           vSize = {0, 0};
1558     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1559     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1560     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1561     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1562     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1563     POINTL                          vPoint[4] = { {0 ,0}, {nWidth, nHeight},
1564                                                   {0, 0}, {nWidth, nHeight}
1565                                                 };
1566
1567     memset(&vBmih, '\0', 16);
1568     vBmih.cbFix     = 16;
1569     vBmih.cx        = nWidth;
1570     vBmih.cy        = nHeight;
1571     vBmih.cPlanes   = 1;
1572     vBmih.cBitCount = 24;
1573
1574     hBmpInvMask = ::GpiCreateBitmap( hPSDst
1575                                     ,&vBmih
1576                                     ,0L
1577                                     ,NULL
1578                                     ,NULL
1579                                    );
1580
1581     ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmpMask);
1582     ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpInvMask);
1583
1584     ::GpiBitBlt( hPSDst
1585                 ,hPSSrc
1586                 ,4L
1587                 ,vPoint
1588                 ,ROP_SRCINVERT
1589                 ,BBO_IGNORE
1590                );
1591
1592     ::GpiDestroyPS(hPSSrc);
1593     ::GpiDestroyPS(hPSDst);
1594     ::DevCloseDC(hDCSrc);
1595     ::DevCloseDC(hDCDst);
1596
1597     return hBmpInvMask;
1598 } // end of WxWinGdi_InvertMask
1599