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(wxT("GpiDeleteBitmap(hbitmap)"));
  69     }
  70     if (m_hBitmap)
  71     {
  72         if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
  73         {
  74             wxLogLastError(wxT("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(wxT("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 reversed!
 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(wxT("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     UnRef();
 416
 417     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 418                                                              ,wxBitmapHandler
 419                                                             );
 420
 421     if (pHandler)
 422     {
 423         m_refData = new wxBitmapRefData;
 424
 425         return(pHandler->LoadFile( this
 426                                   ,nId
 427                                   ,lType
 428                                   , -1
 429                                   , -1
 430                                  ));
 431     }
 432     else
 433     {
 434         return false;
 435     }
 436 } // end of wxBitmap::LoadFile
 437
 438 bool wxBitmap::Create(
 439   void*                             pData
 440 , long                              lType
 441 , int                               nWidth
 442 , int                               nHeight
 443 , int                               nDepth
 444 )
 445 {
 446     UnRef();
 447
 448     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 449                                                              ,wxBitmapHandler
 450                                                             );
 451
 452     if (!pHandler)
 453     {
 454         wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), lType);
 455
 456         return false;
 457     }
 458
 459     m_refData = new wxBitmapRefData;
 460
 461     return(pHandler->Create( this
 462                             ,pData
 463                             ,lType
 464                             ,nWidth
 465                             ,nHeight
 466                             ,nDepth
 467                            ));
 468 } // end of wxBitmap::Create
 469
 470 bool wxBitmap::SaveFile(
 471   const wxString&                   rFilename
 472 , int                               lType
 473 , const wxPalette*                  pPalette
 474 )
 475 {
 476     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 477                                                              ,wxBitmapHandler
 478                                                             );
 479
 480     if (pHandler)
 481     {
 482         return pHandler->SaveFile( this
 483                                   ,rFilename
 484                                   ,lType
 485                                   ,pPalette
 486                                  );
 487     }
 488     else
 489     {
 490         // FIXME what about palette? shouldn't we use it?
 491         wxImage                     vImage = ConvertToImage();
 492
 493         if (!vImage.Ok())
 494             return false;
 495
 496         return(vImage.SaveFile( rFilename
 497                                ,lType
 498                               ));
 499     }
 500 } // end of wxBitmap::SaveFile
 501
 502
 503 // ----------------------------------------------------------------------------
 504 // wxImage-wxBitmap conversion
 505 // ----------------------------------------------------------------------------
 506
 507 bool wxBitmap::CreateFromImage (
 508   const wxImage&                    rImage
 509 , int                               nDepth
 510 )
 511 {
 512     wxCHECK_MSG(rImage.Ok(), false, wxT("invalid image"));
 513     m_refData = new wxBitmapRefData();
 514
 515     int                             nSizeLimit = 1024 * 768 * 3;
 516     int                             nWidth = rImage.GetWidth();
 517     int                             nBmpHeight = rImage.GetHeight();
 518     int                             nBytePerLine = nWidth * 3;
 519     int                             nSizeDWORD = sizeof(DWORD);
 520     int                             nLineBoundary = nBytePerLine % nSizeDWORD;
 521     int                             nPadding = 0;
 522
 523     if (nLineBoundary > 0)
 524     {
 525         nPadding = nSizeDWORD - nLineBoundary;
 526         nBytePerLine += nPadding;
 527     }
 528
 529     //
 530     // Calc the number of DIBs and heights of DIBs
 531     //
 532     int                             nNumDIB = 1;
 533     int                             nHRemain = 0;
 534     int                             nHeight = nSizeLimit / nBytePerLine;
 535
 536     if (nHeight >= nBmpHeight)
 537         nHeight = nBmpHeight;
 538     else
 539     {
 540         nNumDIB  = nBmpHeight / nHeight;
 541         nHRemain = nBmpHeight % nHeight;
 542         if (nHRemain > 0)
 543             nNumDIB++;
 544     }
 545
 546     //
 547     // Set bitmap parameters
 548     //
 549     wxCHECK_MSG(rImage.Ok(), false, wxT("invalid image"));
 550     SetWidth(nWidth);
 551     SetHeight(nBmpHeight);
 552     if (nDepth == 1)
 553         m_bIsMono = true;
 554     else
 555         m_bIsMono = false;
 556     if (nDepth == -1)
 557         nDepth = wxDisplayDepth();
 558     SetDepth(nDepth);
 559
 560 #if wxUSE_PALETTE
 561     //
 562     // Copy the palette from the source image
 563     //
 564     SetPalette(rImage.GetPalette());
 565 #endif // wxUSE_PALETTE
 566
 567     //
 568     // Create a DIB header
 569     //
 570     BITMAPINFOHEADER2               vHeader;
 571     BITMAPINFO2                     vInfo;
 572
 573     //
 574     // Fill in the DIB header
 575     //
 576     memset(&vHeader, '\0', 16);
 577     vHeader.cbFix           = 16;
 578     vHeader.cx              = (ULONG)nWidth;
 579     vHeader.cy              = (ULONG)nHeight;
 580     vHeader.cPlanes         = 1L;
 581     vHeader.cBitCount       = 24;
 582
 583     //
 584     // Memory for DIB data
 585     //
 586     unsigned char*                  pucBits;
 587
 588     pucBits = (unsigned char *)malloc(nBytePerLine * nHeight);
 589     if(!pucBits)
 590     {
 591         wxFAIL_MSG(wxT("could not allocate memory for DIB"));
 592         return false;
 593     }
 594     memset(pucBits, '\0', (nBytePerLine * nHeight));
 595
 596     //
 597     // Create and set the device-dependent bitmap
 598     //
 599     DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 600     SIZEL                           vSize = {0, 0};
 601     HDC                             hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
 602     HPS                             hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 603     LONG                            lScans;
 604     HDC                             hDCScreen = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
 605     HPS                             hPSScreen;
 606     HBITMAP                         hBmp;
 607     HBITMAP                         hBmpOld;
 608
 609     memset(&vInfo, '\0', 16);
 610     vInfo.cbFix           = 16;
 611     vInfo.cx              = (ULONG)nWidth;
 612     vInfo.cy              = (ULONG)nHeight;
 613     vInfo.cPlanes         = 1;
 614     vInfo.cBitCount       = 24; // Set to desired count going in
 615
 616     hBmp = ::GpiCreateBitmap( hPS
 617                              ,&vHeader
 618                              ,0L
 619                              ,NULL
 620                              ,NULL
 621                             );
 622 #if wxUSE_PALETTE
 623     HPAL                            hOldPalette = NULLHANDLE;
 624     if (rImage.GetPalette().Ok())
 625     {
 626         hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE());
 627     }
 628 #endif // wxUSE_PALETTE
 629
 630     //
 631     // Copy image data into DIB data and then into DDB (in a loop)
 632     //
 633     unsigned char*                  pData = rImage.GetData();
 634     int                             i;
 635     int                             j;
 636     int                             n;
 637     int                             nOrigin = 0;
 638     unsigned char*                  ptdata = pData;
 639     unsigned char*                  ptbits;
 640
 641     if ((hBmpOld = ::GpiSetBitmap(hPS, hBmp)) == HBM_ERROR)
 642     {
 643         ERRORID                 vError;
 644         wxString                sError;
 645
 646         vError = ::WinGetLastError(vHabmain);
 647         sError = wxPMErrorToStr(vError);
 648     }
 649     for (n = 0; n < nNumDIB; n++)
 650     {
 651         if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
 652         {
 653             //
 654             // Redefine height and size of the (possibly) last smaller DIB
 655             // memory is not reallocated
 656             //
 657             nHeight         = nHRemain;
 658             vHeader.cy      = (DWORD)(nHeight);
 659             vHeader.cbImage = nBytePerLine * nHeight;
 660         }
 661         ptbits = pucBits;
 662         for (j = 0; j < nHeight; j++)
 663         {
 664             for (i = 0; i < nWidth; i++)
 665             {
 666                 *(ptbits++) = *(ptdata + 2);
 667                 *(ptbits++) = *(ptdata + 1);
 668                 *(ptbits++) = *(ptdata);
 669                 ptdata += 3;
 670             }
 671             for (i = 0; i < nPadding; i++)
 672                 *(ptbits++) = 0;
 673         }
 674
 675         //
 676         // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
 677         // in combination with setting the bits into the selected bitmap
 678         //
 679         if ((lScans = ::GpiSetBitmapBits( hPS
 680                                          ,0             // Start at the bottom
 681                                          ,(LONG)nHeight // One line per scan
 682                                          ,(PBYTE)pucBits
 683                                          ,&vInfo
 684                                        )) == GPI_ALTERROR)
 685         {
 686             ERRORID                 vError;
 687             wxString                sError;
 688
 689             vError = ::WinGetLastError(vHabmain);
 690             sError = wxPMErrorToStr(vError);
 691         }
 692         hPSScreen = ::GpiCreatePS( vHabmain
 693                                   ,hDCScreen
 694                                   ,&vSize
 695                                   ,PU_PELS | GPIA_ASSOC
 696                                  );
 697
 698         POINTL                      vPoint[4] = { {0, nOrigin},
 699                                                   {nWidth, nHeight},
 700                                                   {0, 0}, {nWidth, nHeight}
 701                                                 };
 702
 703
 704         ::GpiBitBlt( hPSScreen
 705                     ,hPS
 706                     ,4
 707                     ,vPoint
 708                     ,ROP_SRCCOPY
 709                     ,BBO_IGNORE
 710                    );
 711         ::GpiDestroyPS(hPSScreen);
 712         nOrigin += nHeight;
 713     }
 714     SetHBITMAP((WXHBITMAP)hBmp);
 715 #if wxUSE_PALETTE
 716     if (hOldPalette)
 717         ::GpiSelectPalette(hPS, hOldPalette);
 718 #endif // wxUSE_PALETTE
 719
 720     //
 721     // Similarly, created an mono-bitmap for the possible mask
 722     //
 723     if (rImage.HasMask())
 724     {
 725         vHeader.cbFix     = 16;
 726         vHeader.cx        = nWidth;
 727         vHeader.cy        = nHeight;
 728         vHeader.cPlanes   = 1;
 729         vHeader.cBitCount = 24;
 730         hBmp = ::GpiCreateBitmap( hPS
 731                                  ,&vHeader
 732                                  ,0L
 733                                  ,NULL
 734                                  ,NULL
 735                                 );
 736         hBmpOld = ::GpiSetBitmap(hPS, hBmp);
 737         if (nNumDIB == 1)
 738             nHeight = nBmpHeight;
 739         else
 740             nHeight = nSizeLimit / nBytePerLine;
 741         vHeader.cy = (DWORD)(nHeight);
 742         nOrigin = 0;
 743
 744         unsigned char               cRed   = rImage.GetMaskRed();
 745         unsigned char               cGreen = rImage.GetMaskGreen();
 746         unsigned char               cBlue  = rImage.GetMaskBlue();
 747         unsigned char               cZero = 0;
 748         unsigned char               cOne = 255;
 749
 750         ptdata = pData;
 751         for (n = 0; n < nNumDIB; n++)
 752         {
 753             if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
 754             {
 755                 //
 756                 // Redefine height and size of the (possibly) last smaller DIB
 757                 // memory is not reallocated
 758                 //
 759                 nHeight         = nHRemain;
 760                 vHeader.cy      = (DWORD)(nHeight);
 761                 vHeader.cbImage = nBytePerLine * nHeight;
 762             }
 763             ptbits = pucBits;
 764             for (int j = 0; j < nHeight; j++)
 765             {
 766                 for (i = 0; i < nWidth; i++)
 767                 {
 768                     unsigned char cRedImage   = (*(ptdata++)) ;
 769                     unsigned char cGreenImage = (*(ptdata++)) ;
 770                     unsigned char cBlueImage  = (*(ptdata++)) ;
 771
 772                     if ((cRedImage != cRed) || (cGreenImage != cGreen) || (cBlueImage != cBlue))
 773                     {
 774                         *(ptbits++) = cOne;
 775                         *(ptbits++) = cOne;
 776                         *(ptbits++) = cOne;
 777                     }
 778                     else
 779                     {
 780                         *(ptbits++) = cZero;
 781                         *(ptbits++) = cZero;
 782                         *(ptbits++) = cZero;
 783                     }
 784                 }
 785                 for (i = 0; i < nPadding; i++)
 786                     *(ptbits++) = cZero;
 787             }
 788             lScans = ::GpiSetBitmapBits( hPS
 789                                         ,0              // Start at the bottom
 790                                         ,(LONG)nHeight // One line per scan
 791                                         ,(PBYTE)pucBits
 792                                         ,&vInfo
 793                                        );
 794             hPSScreen = ::GpiCreatePS( vHabmain
 795                                       ,hDCScreen
 796                                       ,&vSize
 797                                       ,PU_PELS | GPIA_ASSOC
 798                                      );
 799             POINTL vPoint2[4] = { {0, nOrigin},
 800                                   {nWidth, nHeight},
 801                                   {0, 0}, {nWidth, nHeight}
 802                                 };
 803             ::GpiBitBlt( hPSScreen
 804                         ,hPS
 805                         ,4
 806                         ,vPoint2
 807                         ,ROP_SRCCOPY
 808                         ,BBO_IGNORE
 809                    );
 810             ::GpiDestroyPS(hPSScreen);
 811             nOrigin += nHeight;
 812         }
 813
 814         //
 815         // Create a wxMask object
 816         //
 817         wxMask*                     pMask = new wxMask();
 818
 819         pMask->SetMaskBitmap((WXHBITMAP)hBmp);
 820         SetMask(pMask);
 821         hBmpOld = ::GpiSetBitmap(hPS, hBmpOld);
 822     }
 823
 824     //
 825     // Free allocated resources
 826     //
 827     ::GpiSetBitmap(hPS, NULLHANDLE);
 828     ::GpiDestroyPS(hPS);
 829     ::DevCloseDC(hDCScreen);
 830     ::DevCloseDC(hDC);
 831     free(pucBits);
 832     return true;
 833 } // end of wxBitmap::CreateFromImage
 834
 835 wxImage wxBitmap::ConvertToImage() const
 836 {
 837     wxImage                         vImage;
 838     wxDC*                           pDC;
 839
 840     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 841
 842     //
 843     // Create an wxImage object
 844     //
 845     int                             nWidth        = GetWidth();
 846     int                             nHeight       = GetHeight();
 847     int                             nDevWidth;
 848     int                             nDevHeight;
 849     int                             nBytePerLine  = nWidth * 3;
 850     int                             nSizeDWORD    = sizeof(DWORD);
 851     int                             nLineBoundary = nBytePerLine % nSizeDWORD;
 852     int                             nPadding = 0;
 853     unsigned char*                  pData;
 854     unsigned char*                  lpBits;
 855     long                            lScans;
 856     BITMAPINFOHEADER2               vDIBh;
 857     BITMAPINFO2                     vDIBInfo;
 858     HPS                             hPSMem;
 859     HBITMAP                         hBitmap;
 860     HBITMAP                         hOldBitmap;
 861     DEVOPENSTRUC                    vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 862     SIZEL                           vSizlPage = {0,0};
 863     HDC                             hDCMem = NULLHANDLE;
 864
 865     vImage.Create( nWidth
 866                   ,nHeight
 867                  );
 868     pData = vImage.GetData();
 869     if(!pData)
 870     {
 871         wxFAIL_MSG( wxT("could not allocate data for image") );
 872         return wxNullImage;
 873     }
 874     if(nLineBoundary > 0)
 875     {
 876         nPadding     = nSizeDWORD - nLineBoundary;
 877         nBytePerLine += nPadding;
 878     }
 879     wxDisplaySize( &nDevWidth
 880                   ,&nDevHeight
 881                  );
 882     //
 883     // Create and fill a DIB header
 884     //
 885     memset(&vDIBh, '\0', 16);
 886     vDIBh.cbFix     =  16;
 887     vDIBh.cx        = nWidth;
 888     vDIBh.cy        = nHeight;
 889     vDIBh.cPlanes   = 1;
 890     vDIBh.cBitCount = 24;
 891
 892     memset(&vDIBInfo, '\0', 16);
 893     vDIBInfo.cbFix           = 16;
 894     vDIBInfo.cx              = nWidth;
 895     vDIBInfo.cy              = nHeight;
 896     vDIBInfo.cPlanes         = 1;
 897     vDIBInfo.cBitCount       = 24;
 898
 899     lpBits = (unsigned char *)malloc(nBytePerLine * nHeight);
 900     if (!lpBits)
 901     {
 902         wxFAIL_MSG(wxT("could not allocate data for DIB"));
 903         free(pData);
 904         return wxNullImage;
 905     }
 906     memset(lpBits, '\0', (nBytePerLine * nHeight));
 907     hBitmap = (HBITMAP)GetHBITMAP();
 908
 909     //
 910     // May already be selected into a PS
 911     //
 912     if ((pDC = GetSelectedInto()) != NULL)
 913     {
 914         hPSMem = pDC->GetHPS();
 915     }
 916     else
 917     {
 918         hDCMem = ::DevOpenDC( vHabmain
 919                              ,OD_MEMORY
 920                              ,"*"
 921                              ,5L
 922                              ,(PDEVOPENDATA)&vDop
 923                              ,NULLHANDLE
 924                             );
 925         hPSMem = ::GpiCreatePS( vHabmain
 926                                ,hDCMem
 927                                ,&vSizlPage
 928                                ,PU_PELS | GPIA_ASSOC
 929                               );
 930     }
 931     if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
 932     {
 933         ERRORID                 vError;
 934         wxString                sError;
 935
 936         vError = ::WinGetLastError(vHabmain);
 937         sError = wxPMErrorToStr(vError);
 938     }
 939
 940     //
 941     // Copy data from the device-dependent bitmap to the DIB
 942     //
 943     if ((lScans = ::GpiQueryBitmapBits( hPSMem
 944                                        ,0L
 945                                        ,(LONG)nHeight
 946                                        ,(PBYTE)lpBits
 947                                        ,&vDIBInfo
 948                                       )) == GPI_ALTERROR)
 949     {
 950         ERRORID                     vError;
 951         wxString                    sError;
 952
 953         vError = ::WinGetLastError(vHabmain);
 954         sError = wxPMErrorToStr(vError);
 955     }
 956
 957     //
 958     // Copy DIB data into the wxImage object
 959     //
 960     int                             i;
 961     int                             j;
 962     unsigned char*                  ptdata = pData;
 963     unsigned char*                  ptbits = lpBits;
 964
 965     for (i = 0; i < nHeight; i++)
 966     {
 967         for (j = 0; j < nWidth; j++)
 968         {
 969             *(ptdata++) = *(ptbits+2);
 970             *(ptdata++) = *(ptbits+1);
 971             *(ptdata++) = *(ptbits  );
 972             ptbits += 3;
 973         }
 974         ptbits += nPadding;
 975     }
 976     if ((pDC = GetSelectedInto()) == NULL)
 977     {
 978         ::GpiSetBitmap(hPSMem, NULLHANDLE);
 979         ::GpiDestroyPS(hPSMem);
 980         ::DevCloseDC(hDCMem);
 981     }
 982
 983     //
 984     // Similarly, set data according to the possible mask bitmap
 985     //
 986     if (GetMask() && GetMask()->GetMaskBitmap())
 987     {
 988         hBitmap = (HBITMAP)GetMask()->GetMaskBitmap();
 989
 990         //
 991         // Memory DC/PS created, color set, data copied, and memory DC/PS deleted
 992         //
 993         HDC                        hMemDC = ::DevOpenDC( vHabmain
 994                                                         ,OD_MEMORY
 995                                                         ,"*"
 996                                                         ,5L
 997                                                         ,(PDEVOPENDATA)&vDop
 998                                                         ,NULLHANDLE
 999                                                        );
1000         HPS                         hMemPS = ::GpiCreatePS( vHabmain
1001                                                            ,hMemDC
1002                                                            ,&vSizlPage
1003                                                            ,PU_PELS | GPIA_ASSOC
1004                                                           );
1005         ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0));
1006         ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) );
1007         ::GpiSetBitmap(hMemPS, hBitmap);
1008         ::GpiQueryBitmapBits( hPSMem
1009                              ,0L
1010                              ,(LONG)nHeight
1011                              ,(PBYTE)lpBits
1012                              ,&vDIBInfo
1013                             );
1014         ::GpiSetBitmap(hMemPS, NULLHANDLE);
1015         ::GpiDestroyPS(hMemPS);
1016         ::DevCloseDC(hMemDC);
1017
1018         //
1019         // Background color set to RGB(16,16,16) in consistent with wxGTK
1020         //
1021         unsigned char               ucRed = 16;
1022         unsigned char               ucGreen = 16;
1023         unsigned char               ucBlue = 16;
1024
1025         ptdata = pData;
1026         ptbits = lpBits;
1027         for (i = 0; i < nHeight; i++)
1028         {
1029             for (j = 0; j < nWidth; j++)
1030             {
1031                 if (*ptbits != 0)
1032                     ptdata += 3;
1033                 else
1034                 {
1035                     *(ptdata++)  = ucRed;
1036                     *(ptdata++)  = ucGreen;
1037                     *(ptdata++)  = ucBlue;
1038                 }
1039                 ptbits += 3;
1040             }
1041             ptbits += nPadding;
1042         }
1043         vImage.SetMaskColour( ucRed
1044                              ,ucGreen
1045                              ,ucBlue
1046                             );
1047         vImage.SetMask(true);
1048     }
1049     else
1050     {
1051         vImage.SetMask(false);
1052     }
1053
1054     //
1055     // Free allocated resources
1056     //
1057     free(lpBits);
1058     return vImage;
1059 } // end of wxBitmap::ConvertToImage
1060
1061 // ----------------------------------------------------------------------------
1062 // sub bitmap extraction
1063 // ----------------------------------------------------------------------------
1064
1065 wxBitmap wxBitmap::GetSubBitmap(
1066   const wxRect&                     rRect
1067 ) const
1068 {
1069     wxCHECK_MSG( Ok() &&
1070                  (rRect.x >= 0) && (rRect.y >= 0) &&
1071                  (rRect.x + rRect.width <= GetWidth()) &&
1072                  (rRect.y + rRect.height <= GetHeight()),
1073                  wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
1074
1075     wxBitmap                        vRet( rRect.width
1076                                          ,rRect.height
1077                                          ,GetDepth()
1078                                         );
1079     wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") );
1080
1081
1082     //
1083     // Copy bitmap data
1084     //
1085     SIZEL                           vSize = {0, 0};
1086     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1087     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1088     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1089     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1090     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1091     POINTL                          vPoint[4] = { {0, 0}, {rRect.width, rRect.height},
1092                                                   {rRect.x, rRect.y},
1093                                                   {rRect.x + rRect.width, rRect.y + rRect.height}
1094                                                 };
1095
1096     ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
1097     ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
1098     ::GpiBitBlt( hPSDst
1099                 ,hPSSrc
1100                 ,4L
1101                 ,vPoint
1102                 ,ROP_SRCCOPY
1103                 ,BBO_IGNORE
1104                );
1105
1106     //
1107     // Copy mask if there is one
1108     //
1109     if (GetMask())
1110     {
1111         BITMAPINFOHEADER2           vBmih;
1112
1113         memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1114         vBmih.cbFix     = sizeof(BITMAPINFOHEADER2);
1115         vBmih.cx        = rRect.width;
1116         vBmih.cy        = rRect.height;
1117         vBmih.cPlanes   = 1;
1118         vBmih.cBitCount = 24;
1119
1120         HBITMAP                     hBmpMask = ::GpiCreateBitmap( hPSDst
1121                                                                  ,&vBmih
1122                                                                  ,0L
1123                                                                  ,NULL
1124                                                                  ,NULL
1125                                                                 );
1126
1127         ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
1128         ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
1129
1130         ::GpiSetBitmap(hPSSrc, (HBITMAP) GetMask()->GetMaskBitmap());
1131         ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpMask);
1132         ::GpiBitBlt( hPSDst
1133                     ,hPSSrc
1134                     ,4L
1135                     ,vPoint
1136                     ,ROP_SRCCOPY
1137                     ,BBO_IGNORE
1138                    );
1139
1140         wxMask*                     pMask = new wxMask((WXHBITMAP)hBmpMask);
1141         vRet.SetMask(pMask);
1142     }
1143
1144     ::GpiSetBitmap(hPSSrc, NULL);
1145     ::GpiSetBitmap(hPSDst, NULL);
1146     ::GpiDestroyPS(hPSSrc);
1147     ::GpiDestroyPS(hPSDst);
1148     ::DevCloseDC(hDCSrc);
1149     ::DevCloseDC(hDCDst);
1150     return vRet;
1151 } // end of wxBitmap::GetSubBitmap
1152
1153 // ----------------------------------------------------------------------------
1154 // wxBitmap accessors
1155 // ----------------------------------------------------------------------------
1156
1157 void wxBitmap::SetQuality(
1158   int                               nQ
1159 )
1160 {
1161     EnsureHasData();
1162
1163     GetBitmapData()->m_nQuality = nQ;
1164 } // end of wxBitmap::SetQuality
1165
1166 void wxBitmap::SetPalette(
1167   const wxPalette&                  rPalette
1168 )
1169 {
1170     EnsureHasData();
1171
1172     GetBitmapData()->m_vBitmapPalette = rPalette;
1173 } // end of wxBitmap::SetPalette
1174
1175 void wxBitmap::SetMask(
1176   wxMask*                           pMask
1177 )
1178 {
1179     EnsureHasData();
1180
1181     GetBitmapData()->m_pBitmapMask = pMask;
1182 } // end of wxBitmap::SetMask
1183
1184 wxBitmap wxBitmap::GetBitmapForDC(
1185   wxDC&                             rDc
1186 ) const
1187 {
1188     return(*this);
1189 } // end of wxBitmap::GetBitmapForDC
1190
1191 // ----------------------------------------------------------------------------
1192 // wxMask
1193 // ----------------------------------------------------------------------------
1194
1195 wxMask::wxMask()
1196 {
1197     m_hMaskBitmap = 0;
1198 } // end of wxMask::wxMask
1199
1200 // Construct a mask from a bitmap and a colour indicating
1201 // the transparent area
1202 wxMask::wxMask(
1203   const wxBitmap&                   rBitmap
1204 , const wxColour&                   rColour
1205 )
1206 {
1207     m_hMaskBitmap = 0;
1208     Create( rBitmap
1209            ,rColour
1210           );
1211 } // end of wxMask::wxMask
1212
1213 // Construct a mask from a bitmap and a palette index indicating
1214 // the transparent area
1215 wxMask::wxMask(
1216   const wxBitmap&                   rBitmap
1217 , int                               nPaletteIndex
1218 )
1219 {
1220     m_hMaskBitmap = 0;
1221     Create( rBitmap
1222            ,nPaletteIndex
1223           );
1224 } // end of wxMask::wxMask
1225
1226 // Construct a mask from a mono bitmap (copies the bitmap).
1227 wxMask::wxMask(
1228   const wxBitmap&                   rBitmap
1229 )
1230 {
1231     m_hMaskBitmap = 0;
1232     Create(rBitmap);
1233 } // end of wxMask::wxMask
1234
1235 wxMask::~wxMask()
1236 {
1237     if (m_hMaskBitmap)
1238         ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
1239 } // end of wxMask::~wxMask
1240
1241 // Create a mask from a mono bitmap (copies the bitmap).
1242 bool wxMask::Create(
1243   const wxBitmap&                   rBitmap
1244 )
1245 {
1246     BITMAPINFOHEADER2               vBmih;
1247     SIZEL                           vSize = {0, 0};
1248     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1249     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1250     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1251     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1252     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1253     POINTL                          vPoint[4] = { {0 ,0}, {rBitmap.GetWidth(), rBitmap.GetHeight()},
1254                                                   {0, 0}, {rBitmap.GetWidth(), rBitmap.GetHeight()}
1255                                                 };
1256
1257     if (m_hMaskBitmap)
1258     {
1259         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1260         m_hMaskBitmap = 0;
1261     }
1262     if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
1263     {
1264         return false;
1265     }
1266
1267     memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1268     vBmih.cbFix     =  sizeof(BITMAPINFOHEADER2);
1269     vBmih.cx        = rBitmap.GetWidth();
1270     vBmih.cy        = rBitmap.GetHeight();
1271     vBmih.cPlanes   = 1;
1272     vBmih.cBitCount = 24;
1273
1274     m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1275                                       ,&vBmih
1276                                       ,0L
1277                                       ,NULL
1278                                       ,NULL
1279                                      );
1280
1281     ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1282     ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1283     ::GpiBitBlt( hPSDst
1284                 ,hPSSrc
1285                 ,4L
1286                 ,vPoint
1287                 ,ROP_SRCCOPY
1288                 ,BBO_IGNORE
1289                );
1290
1291     ::GpiDestroyPS(hPSSrc);
1292     ::GpiDestroyPS(hPSDst);
1293     ::DevCloseDC(hDCSrc);
1294     ::DevCloseDC(hDCDst);
1295     return true;
1296 } // end of wxMask::Create
1297
1298 // Create a mask from a bitmap and a palette index indicating
1299 // the transparent area
1300 bool wxMask::Create(
1301   const wxBitmap&                   rBitmap
1302 , int                               nPaletteIndex
1303 )
1304 {
1305     if (m_hMaskBitmap)
1306     {
1307         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1308         m_hMaskBitmap = 0;
1309     }
1310     if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
1311     {
1312         unsigned char               cRed;
1313         unsigned char               cGreen;
1314         unsigned char               cBlue;
1315
1316         if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
1317                                          ,&cRed
1318                                          ,&cGreen
1319                                          ,&cBlue
1320                                         ))
1321         {
1322             wxColour                vTransparentColour( cRed
1323                                                        ,cGreen
1324                                                        ,cBlue
1325                                                       );
1326
1327             return (Create( rBitmap
1328                            ,vTransparentColour
1329                           ));
1330         }
1331     }
1332     return false;
1333 } // end of wxMask::Create
1334
1335 // Create a mask from a bitmap and a colour indicating
1336 // the transparent area
1337 bool wxMask::Create(
1338   const wxBitmap&                   rBitmap
1339 , const wxColour&                   rColour
1340 )
1341 {
1342     bool                            bOk = true;
1343     COLORREF                        vMaskColour = OS2RGB( rColour.Red()
1344                                                          ,rColour.Green()
1345                                                          ,rColour.Blue()
1346                                                         );
1347     BITMAPINFOHEADER2               vBmih;
1348     SIZEL                           vSize = {0, 0};
1349     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
1350     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1351     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1352     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1353     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1354
1355     if (m_hMaskBitmap)
1356     {
1357         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1358         m_hMaskBitmap = 0;
1359     }
1360     if (!rBitmap.Ok())
1361     {
1362         return false;
1363     }
1364
1365     //
1366     // Scan the bitmap for the transparent colour and set
1367     // the corresponding pixels in the mask to BLACK and
1368     // the rest to WHITE
1369     //
1370
1371     memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1372     vBmih.cbFix     =  sizeof(BITMAPINFOHEADER2);
1373     vBmih.cx        = rBitmap.GetWidth();
1374     vBmih.cy        = rBitmap.GetHeight();
1375     vBmih.cPlanes   = 1;
1376     vBmih.cBitCount = 1;
1377
1378     m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1379                                       ,&vBmih
1380                                       ,0L
1381                                       ,NULL
1382                                       ,NULL
1383                                      );
1384
1385     ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1386     ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1387
1388     //
1389     // This is not very efficient, but I can't think
1390     // of a better way of doing it
1391     //
1392     for (int w = 0; w < rBitmap.GetWidth(); w++)
1393     {
1394         for (int h = 0; h < rBitmap.GetHeight(); h++)
1395         {
1396             POINTL                  vPt = {w, h};
1397             COLORREF                vCol = (COLORREF)::GpiQueryPel(hPSSrc, &vPt);
1398             if (vCol == (COLORREF)CLR_NOINDEX)
1399             {
1400                 //
1401                 // Doesn't make sense to continue
1402                 //
1403                 bOk = false;
1404                 break;
1405             }
1406
1407             if (vCol == vMaskColour)
1408             {
1409                 ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0));
1410                 ::GpiSetPel(hPSDst, &vPt);
1411             }
1412             else
1413             {
1414                 ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255));
1415                 ::GpiSetPel(hPSDst, &vPt);
1416             }
1417         }
1418     }
1419     ::GpiSetBitmap(hPSSrc, NULL);
1420     ::GpiSetBitmap(hPSDst, NULL);
1421     ::GpiDestroyPS(hPSSrc);
1422     ::GpiDestroyPS(hPSDst);
1423     ::DevCloseDC(hDCSrc);
1424     ::DevCloseDC(hDCDst);
1425     return true;
1426 } // end of wxMask::Create
1427
1428 // ----------------------------------------------------------------------------
1429 // wxBitmapHandler
1430 // ----------------------------------------------------------------------------
1431
1432 bool wxBitmapHandler::Create(
1433   wxGDIImage*                       pImage
1434 , void*                             pData
1435 , long                              lFlags
1436 , int                               nWidth
1437 , int                               nHeight
1438 , int                               nDepth
1439 )
1440 {
1441     wxBitmap*                       pBitmap = wxDynamicCast( pImage
1442                                                             ,wxBitmap
1443                                                            );
1444
1445     return(pBitmap ? Create( pBitmap
1446                             ,pData
1447                             ,nWidth
1448                             ,nHeight
1449                             ,nDepth
1450                            ) : false);
1451 }
1452
1453 bool wxBitmapHandler::Load(
1454   wxGDIImage*                       pImage
1455 , int                               nId
1456 , long                              lFlags
1457 , int                               nWidth
1458 , int                               nHeight
1459 )
1460 {
1461     wxBitmap*                       pBitmap = wxDynamicCast( pImage
1462                                                             ,wxBitmap
1463                                                            );
1464
1465     return(pBitmap ? LoadFile( pBitmap
1466                               ,nId
1467                               ,lFlags
1468                               ,nWidth
1469                               ,nHeight
1470                              ) : false);
1471 }
1472
1473 bool wxBitmapHandler::Save(
1474   wxGDIImage*                       pImage
1475 , const wxString&                   rName
1476 , int                               lType
1477 )
1478 {
1479     wxBitmap*                       pBitmap = wxDynamicCast( pImage
1480                                                             ,wxBitmap
1481                                                            );
1482
1483     return(pBitmap ? SaveFile( pBitmap
1484                               ,rName
1485                               ,lType
1486                              ) : false);
1487 }
1488
1489 bool wxBitmapHandler::Create(
1490   wxBitmap*                         WXUNUSED(pBitmap)
1491 , void*                             WXUNUSED(pData)
1492 , long                              WXUNUSED(lType)
1493 , int                               WXUNUSED(nWidth)
1494 , int                               WXUNUSED(nHeight)
1495 , int                               WXUNUSED(nDepth)
1496 )
1497 {
1498     return false;
1499 }
1500
1501 bool wxBitmapHandler::LoadFile(
1502   wxBitmap*                         WXUNUSED(pBitmap)
1503 , int                               WXUNUSED(nId)
1504 , long                              WXUNUSED(lType)
1505 , int                               WXUNUSED(nDesiredWidth)
1506 , int                               WXUNUSED(nDesiredHeight)
1507 )
1508 {
1509     return false;
1510 }
1511
1512 bool wxBitmapHandler::SaveFile(
1513   wxBitmap*                         WXUNUSED(pBitmap)
1514 , const wxString&                   WXUNUSED(rName)
1515 , int                               WXUNUSED(nType)
1516 , const wxPalette*                  WXUNUSED(pPalette)
1517 )
1518 {
1519     return false;
1520 }
1521
1522 // ----------------------------------------------------------------------------
1523 // Utility functions
1524 // ----------------------------------------------------------------------------
1525 HBITMAP wxInvertMask(
1526   HBITMAP                           hBmpMask
1527 , int                               nWidth
1528 , int                               nHeight
1529 )
1530 {
1531     HBITMAP                         hBmpInvMask = 0;
1532
1533     wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") );
1534
1535     //
1536     // Get width/height from the bitmap if not given
1537     //
1538     if (!nWidth || !nHeight)
1539     {
1540         BITMAPINFOHEADER2           vBmhdr;
1541
1542         ::GpiQueryBitmapInfoHeader( hBmpMask
1543                                    ,&vBmhdr
1544                                   );
1545         nWidth  = (int)vBmhdr.cx;
1546         nHeight = (int)vBmhdr.cy;
1547     }
1548
1549     BITMAPINFOHEADER2               vBmih;
1550     SIZEL                           vSize = {0, 0};
1551     DEVOPENSTRUC                    vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1552     HDC                             hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1553     HDC                             hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1554     HPS                             hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1555     HPS                             hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1556     POINTL                          vPoint[4] = { {0 ,0}, {nWidth, nHeight},
1557                                                   {0, 0}, {nWidth, nHeight}
1558                                                 };
1559
1560     memset(&vBmih, '\0', 16);
1561     vBmih.cbFix     = 16;
1562     vBmih.cx        = nWidth;
1563     vBmih.cy        = nHeight;
1564     vBmih.cPlanes   = 1;
1565     vBmih.cBitCount = 24;
1566
1567     hBmpInvMask = ::GpiCreateBitmap( hPSDst
1568                                     ,&vBmih
1569                                     ,0L
1570                                     ,NULL
1571                                     ,NULL
1572                                    );
1573
1574     ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmpMask);
1575     ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpInvMask);
1576
1577     ::GpiBitBlt( hPSDst
1578                 ,hPSSrc
1579                 ,4L
1580                 ,vPoint
1581                 ,ROP_SRCINVERT
1582                 ,BBO_IGNORE
1583                );
1584
1585     ::GpiDestroyPS(hPSSrc);
1586     ::GpiDestroyPS(hPSDst);
1587     ::DevCloseDC(hDCSrc);
1588     ::DevCloseDC(hDCDst);
1589
1590     return hBmpInvMask;
1591 } // end of WxWinGdi_InvertMask
1592