src/os2/bitmap.cpp

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