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