src/os2/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        bitmap.cpp
   3 // Purpose:     wxBitmap
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     08/08/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include <stdio.h>
  17
  18     #include "wx/list.h"
  19     #include "wx/utils.h"
  20     #include "wx/app.h"
  21     #include "wx/palette.h"
  22     #include "wx/dcmemory.h"
  23     #include "wx/bitmap.h"
  24     #include "wx/icon.h"
  25 #endif
  26
  27 #include "wx/os2/private.h"
  28 #include "wx/log.h"
  29
  30 //#include "wx/msw/dib.h"
  31 #include "wx/image.h"
  32
  33 // ----------------------------------------------------------------------------
  34 // macros
  35 // ----------------------------------------------------------------------------
  36
  37 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
  38 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  39
  40 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
  41
  42 // ============================================================================
  43 // implementation
  44 // ============================================================================
  45
  46 // ----------------------------------------------------------------------------
  47 // wxBitmapRefData
  48 // ----------------------------------------------------------------------------
  49
  50 wxBitmapRefData::wxBitmapRefData()
  51 {
  52     m_nQuality      = 0;
  53     m_pSelectedInto = NULL;
  54     m_nNumColors    = 0;
  55     m_pBitmapMask   = NULL;
  56 }
  57
  58 void wxBitmapRefData::Free()
  59 {
  60     wxASSERT_MSG( !m_pSelectedInto,
  61                   wxT("deleting bitmap still selected into wxMemoryDC") );
  62
  63     if (m_hBitmap)
  64     {
  65         if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
  66         {
  67             wxLogLastError("GpiDeleteBitmap(hbitmap)");
  68         }
  69     }
  70
  71     delete m_pBitmapMask;
  72     m_pBitmapMask = NULL;
  73 }
  74
  75 // ----------------------------------------------------------------------------
  76 // wxBitmap creation
  77 // ----------------------------------------------------------------------------
  78
  79 // this function should be called from all wxBitmap ctors
  80 void wxBitmap::Init()
  81 {
  82     // m_refData = NULL; done in the base class ctor
  83
  84     if (wxTheBitmapList)
  85         wxTheBitmapList->AddBitmap(this);
  86 }
  87
  88 bool wxBitmap::CopyFromIconOrCursor(
  89   const wxGDIImage&                 rIcon
  90 )
  91 {
  92     wxBitmapRefData*                pRefData = new wxBitmapRefData;
  93
  94     m_refData = pRefData;
  95
  96     pRefData->m_nWidth = rIcon.GetWidth();
  97     pRefData->m_nHeight = rIcon.GetHeight();
  98     pRefData->m_nDepth = wxDisplayDepth();
  99
 100     pRefData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle();
 101     // no mask???
 102     pRefData->m_pBitmapMask = new wxMask();
 103
 104 #if WXWIN_COMPATIBILITY_2
 105     pRefData->m_bOk = TRUE;
 106 #endif // WXWIN_COMPATIBILITY_2
 107     return(TRUE);
 108 }
 109
 110 bool wxBitmap::CopyFromCursor(
 111   const wxCursor&                   rCursor
 112 )
 113 {
 114     UnRef();
 115
 116     if (!rCursor.Ok())
 117         return(FALSE);
 118     return(CopyFromIconOrCursor(rCursor));
 119 }
 120
 121 bool wxBitmap::CopyFromIcon(
 122   const wxIcon&                     rIcon
 123 )
 124 {
 125     UnRef();
 126
 127     if (!rIcon.Ok())
 128         return(FALSE);
 129
 130 #if WXWIN_COMPATIBILITY_2
 131     refData->m_ok = TRUE;
 132 #endif // WXWIN_COMPATIBILITY_2
 133
 134     return CopyFromIconOrCursor(rIcon);
 135 }
 136
 137 wxBitmap::~wxBitmap()
 138 {
 139     if (wxTheBitmapList)
 140         wxTheBitmapList->DeleteObject(this);
 141 }
 142
 143 wxBitmap::wxBitmap(
 144   const char                        zBits[]
 145 , int                               nTheWidth
 146 , int                               nTheHeight
 147 , int                               nNoBits
 148 )
 149 {
 150     Init();
 151
 152     wxBitmapRefData*                pRefData = new wxBitmapRefData;
 153     BITMAPINFOHEADER2               vHeader;
 154     BITMAPINFO2                     vInfo;
 155     HDC                             hDc;
 156     HPS                             hPs;
 157     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 158     SIZEL                           vSize = {0, 0};
 159
 160     wxASSERT(vHabmain != NULL);
 161
 162     hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
 163
 164     vHeader.cbFix           = sizeof(vHeader);
 165     vHeader.cx              = (USHORT)nTheWidth;
 166     vHeader.cy              = (USHORT)nTheHeight;
 167     vHeader.cPlanes         = 1L;
 168     vHeader.cBitCount       = nNoBits;
 169     vHeader.ulCompression   = BCA_UNCOMP;
 170     vHeader.cxResolution    = 0;
 171     vHeader.cyResolution    = 0;
 172     vHeader.cclrUsed        = 0;
 173     vHeader.cclrImportant   = 0;
 174     vHeader.usUnits         = BRU_METRIC;
 175     vHeader.usRecording     = BRA_BOTTOMUP;
 176     vHeader.usRendering     = BRH_NOTHALFTONED;
 177     vHeader.cSize1          = 0;
 178     vHeader.cSize2          = 0;
 179     vHeader.ulColorEncoding = 0;
 180     vHeader.ulIdentifier    = 0;
 181
 182     hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
 183     if (hPs == 0)
 184     {
 185         wxLogLastError("GpiCreatePS Failure");
 186     }
 187
 188     m_refData = pRefData;
 189
 190     pRefData->m_nWidth = nTheWidth;
 191     pRefData->m_nHeight = nTheHeight;
 192     pRefData->m_nDepth = nNoBits;
 193     pRefData->m_nNumColors = 0;
 194     pRefData->m_pSelectedInto = NULL;
 195
 196     HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
 197     if (!hBmp)
 198     {
 199         wxLogLastError("CreateBitmap");
 200     }
 201     SetHBITMAP((WXHBITMAP)hBmp);
 202 }
 203
 204 // Create from XPM data
 205 wxBitmap::wxBitmap(
 206   char**                            ppData
 207 , wxControl*                        WXUNUSED(pAnItem))
 208 {
 209     Init();
 210
 211     (void)Create( (void *)ppData
 212                  ,wxBITMAP_TYPE_XPM_DATA
 213                  ,0
 214                  ,0
 215                  ,0
 216                 );
 217 }
 218
 219 wxBitmap::wxBitmap(
 220   int                               nW
 221 , int                               nH
 222 , int                               nD
 223 )
 224 {
 225     Init();
 226
 227     (void)Create( nW
 228                  ,nH
 229                  ,nD
 230                 );
 231 }
 232
 233 wxBitmap::wxBitmap(
 234   void*                             pData
 235 , long                              lType
 236 , int                               nWidth
 237 , int                               nHeight
 238 , int                               nDepth
 239 )
 240 {
 241     Init();
 242
 243     (void)Create( pData
 244                  ,lType
 245                  ,nWidth
 246                  ,nHeight
 247                  ,nDepth
 248                 );
 249 }
 250
 251 wxBitmap::wxBitmap(
 252   const wxString&                   rFilename
 253 , long                              lType
 254 )
 255 {
 256     Init();
 257
 258     LoadFile( rFilename
 259              ,(int)lType
 260             );
 261 }
 262
 263 bool wxBitmap::Create(
 264   int                               nW
 265 , int                               nH
 266 , int                               nD
 267 )
 268 {
 269     HBITMAP                         hBmp;
 270     BITMAPINFOHEADER2               vHeader;
 271     BITMAPINFO2                     vInfo;
 272     HPS                             hpsScreen;
 273     HDC                             hdcScreen;
 274     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 275     SIZEL                           vSize = {0, 0};
 276     LONG                            lBitCount;
 277
 278     wxASSERT(vHabmain != NULL);
 279
 280     hpsScreen = ::WinGetScreenPS(HWND_DESKTOP);
 281     hdcScreen = ::GpiQueryDevice(hpsScreen);
 282     ::DevQueryCaps(hdcScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 283
 284     vHeader.cbFix           = sizeof(vHeader);
 285     vHeader.cx              = (USHORT)nW;
 286     vHeader.cy              = (USHORT)nH;
 287     vHeader.cPlanes         = (USHORT)nD;
 288     vHeader.cBitCount       = lBitCount;
 289     vHeader.ulCompression   = BCA_UNCOMP;
 290     vHeader.cxResolution    = 0;
 291     vHeader.cyResolution    = 0;
 292     vHeader.cclrUsed        = 0;
 293     vHeader.cclrImportant   = 0;
 294     vHeader.usUnits         = BRU_METRIC;
 295     vHeader.usRecording     = BRA_BOTTOMUP;
 296     vHeader.usRendering     = BRH_NOTHALFTONED;
 297     vHeader.cSize1          = 0;
 298     vHeader.cSize2          = 0;
 299     vHeader.ulColorEncoding = 0;
 300     vHeader.ulIdentifier    = 0;
 301
 302     UnRef();
 303     m_refData = new wxBitmapRefData;
 304
 305     GetBitmapData()->m_nWidth = nW;
 306     GetBitmapData()->m_nHeight = nH;
 307     GetBitmapData()->m_nDepth = nD;
 308
 309     if (nD > 0)
 310     {
 311         hBmp = ::GpiCreateBitmap(hpsScreen, &vHeader, 0L, NULL, &vInfo);
 312         if (!hBmp)
 313         {
 314             wxLogLastError("CreateBitmap");
 315         }
 316     }
 317     else
 318     {
 319         LONG                            lPlanes;
 320
 321         ::DevQueryCaps(hdcScreen, CAPS_COLOR_PLANES, 1L, &lPlanes);
 322         hBmp = ::GpiCreateBitmap(hpsScreen, &vHeader, 0L, NULL, &vInfo);
 323         if (!hBmp)
 324         {
 325             wxLogLastError("CreateBitmap");
 326         }
 327         GetBitmapData()->m_nDepth = wxDisplayDepth();
 328     }
 329     SetHBITMAP((WXHBITMAP)hBmp);
 330
 331 #if WXWIN_COMPATIBILITY_2
 332     GetBitmapData()->m_bOk = hBmp != 0;
 333 #endif // WXWIN_COMPATIBILITY_2
 334
 335     return Ok();
 336 }
 337
 338 bool wxBitmap::LoadFile(
 339   const wxString&                   rFilename
 340 , long                              lType
 341 )
 342 {
 343     UnRef();
 344
 345     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 346                                                              ,wxBitmapHandler
 347                                                             );
 348
 349     if (pHandler)
 350     {
 351         m_refData = new wxBitmapRefData;
 352
 353         return(pHandler->LoadFile( this
 354                                   ,rFilename
 355                                   ,lType
 356                                   , -1
 357                                   , -1
 358                                  ));
 359     }
 360     else
 361     {
 362         wxImage                     vImage;
 363
 364         if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
 365             return(FALSE);
 366
 367         *this = vImage.ConvertToBitmap();
 368
 369         return(TRUE);
 370     }
 371 }
 372
 373 bool wxBitmap::Create(
 374   void*                             pData
 375 , long                              lType
 376 , int                               nWidth
 377 , int                               nHeight
 378 , int                               nDepth
 379 )
 380 {
 381     UnRef();
 382
 383     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 384                                                              ,wxBitmapHandler
 385                                                             );
 386
 387     if (!pHandler)
 388     {
 389         wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
 390                        "type %d defined."), lType);
 391
 392         return(FALSE);
 393     }
 394
 395     m_refData = new wxBitmapRefData;
 396
 397     return(pHandler->Create( this
 398                             ,pData
 399                             ,lType
 400                             ,nWidth
 401                             ,nHeight
 402                             ,nDepth
 403                            ));
 404 }
 405
 406 bool wxBitmap::SaveFile(
 407   const wxString&                   rFilename
 408 , int                               lType
 409 , const wxPalette*                  pPalette
 410 )
 411 {
 412     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 413                                                              ,wxBitmapHandler
 414                                                             );
 415
 416     if (pHandler)
 417     {
 418         return pHandler->SaveFile( this
 419                                   ,rFilename
 420                                   ,lType
 421                                   ,pPalette
 422                                  );
 423     }
 424     else
 425     {
 426         // FIXME what about palette? shouldn't we use it?
 427         wxImage                     vImage(*this);
 428
 429         if (!vImage.Ok())
 430             return(FALSE);
 431
 432         return(vImage.SaveFile( rFilename
 433                                ,lType
 434                               ));
 435     }
 436 }
 437
 438 // ----------------------------------------------------------------------------
 439 // wxBitmap accessors
 440 // ----------------------------------------------------------------------------
 441
 442 void wxBitmap::SetQuality(
 443   int                               nQ
 444 )
 445 {
 446     EnsureHasData();
 447
 448     GetBitmapData()->m_nQuality = nQ;
 449 }
 450
 451 #if WXWIN_COMPATIBILITY_2
 452 void wxBitmap::SetOk(
 453   bool                              bOk
 454 )
 455 {
 456     EnsureHasData();
 457
 458     GetBitmapData()->m_bOk = bOk;
 459 }
 460 #endif // WXWIN_COMPATIBILITY_2
 461
 462 void wxBitmap::SetPalette(
 463   const wxPalette&                  rPalette
 464 )
 465 {
 466     EnsureHasData();
 467
 468     GetBitmapData()->m_vBitmapPalette = rPalette;
 469 }
 470
 471 void wxBitmap::SetMask(
 472   wxMask*                           pMask
 473 )
 474 {
 475     EnsureHasData();
 476
 477     GetBitmapData()->m_pBitmapMask = pMask;
 478 }
 479
 480 // Will try something for OS/2 but not really sure how close
 481 // to the msw intent this is.
 482 wxBitmap wxBitmap::GetBitmapForDC(
 483   wxDC&                             rDc
 484 ) const
 485 {
 486     wxMemoryDC                      vMemDC;
 487     wxBitmap                        vTmpBitmap( this->GetWidth()
 488                                                ,this->GetHeight()
 489                                                ,rDc.GetDepth()
 490                                               );
 491     WXHBITMAP                       vOldBitmap;
 492     HPS                             hMemoryPS;
 493     HPS                             hPs;
 494     POINTL                          vPoint[4];
 495     SIZEL                           vSize = {0,0};
 496
 497     hMemoryPS = ::GpiCreatePS(vHabmain, (HDC)vMemDC.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 498     hPs       = ::GpiCreatePS(vHabmain, (HDC)rDc.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 499
 500     // TODO: Set the points
 501
 502     vOldBitmap = (WXHBITMAP)::GpiSetBitmap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
 503     ::GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY, BBO_IGNORE);
 504
 505     return(vTmpBitmap);
 506 }
 507
 508 // ----------------------------------------------------------------------------
 509 // wxMask
 510 // ----------------------------------------------------------------------------
 511
 512 wxMask::wxMask()
 513 {
 514     m_hMaskBitmap = 0;
 515 }
 516
 517 // Construct a mask from a bitmap and a colour indicating
 518 // the transparent area
 519 wxMask::wxMask(
 520   const wxBitmap&                   rBitmap
 521 , const wxColour&                   rColour
 522 )
 523 {
 524     m_hMaskBitmap = 0;
 525     Create( rBitmap
 526            ,rColour
 527           );
 528 }
 529
 530 // Construct a mask from a bitmap and a palette index indicating
 531 // the transparent area
 532 wxMask::wxMask(
 533   const wxBitmap&                   rBitmap
 534 , int                               nPaletteIndex
 535 )
 536 {
 537     m_hMaskBitmap = 0;
 538     Create( rBitmap
 539            ,nPaletteIndex
 540           );
 541 }
 542
 543 // Construct a mask from a mono bitmap (copies the bitmap).
 544 wxMask::wxMask(
 545   const wxBitmap&                   rBitmap
 546 )
 547 {
 548     m_hMaskBitmap = 0;
 549     Create(rBitmap);
 550 }
 551
 552 wxMask::~wxMask()
 553 {
 554     if (m_hMaskBitmap)
 555         ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
 556 }
 557
 558 // Create a mask from a mono bitmap (copies the bitmap).
 559 bool wxMask::Create(
 560   const wxBitmap&                   rBitmap
 561 )
 562 {
 563     BITMAPINFOHEADER2               vHeader;
 564     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 565     SIZEL                           vSize = {0, 0};
 566     POINTL                          vPoint[4];
 567
 568     if (m_hMaskBitmap)
 569     {
 570         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
 571         m_hMaskBitmap = 0;
 572     }
 573     if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
 574     {
 575         return(FALSE);
 576     }
 577     vHeader.cbFix           = sizeof(vHeader);
 578     vHeader.cx              = (USHORT)rBitmap.GetWidth();
 579     vHeader.cy              = (USHORT)rBitmap.GetHeight();
 580     vHeader.cPlanes         = 1;
 581     vHeader.cBitCount       = 1;
 582
 583     m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
 584                                                   ,&vHeader
 585                                                   ,0L
 586                                                   ,NULL
 587                                                   ,NULL
 588                                                  );
 589
 590     HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 591     ::GpiSetBitmap(srcPS, (HBITMAP)rBitmap.GetHBITMAP());
 592     HPS destPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 593     ::GpiSetBitmap(srcPS, (HBITMAP)m_hMaskBitmap);
 594     // TODO: Set the point array
 595     ::GpiBitBlt(destPS, srcPS, 4L, vPoint, ROP_SRCCOPY , BBO_IGNORE);
 596
 597     ::GpiDestroyPS(srcPS);
 598     ::GpiDestroyPS(destPS);
 599     return(TRUE);
 600 }
 601
 602 // Create a mask from a bitmap and a palette index indicating
 603 // the transparent area
 604 bool wxMask::Create(
 605   const wxBitmap&                   rBitmap
 606 , int                               nPaletteIndex
 607 )
 608 {
 609     if (m_hMaskBitmap)
 610     {
 611         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
 612         m_hMaskBitmap = 0;
 613     }
 614     if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
 615     {
 616         unsigned char               cRed;
 617         unsigned char               cGreen;
 618         unsigned char               cBlue;
 619
 620         if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
 621                                          ,&cRed
 622                                          ,&cGreen
 623                                          ,&cBlue
 624                                         ))
 625         {
 626             wxColour                vTransparentColour( cRed
 627                                                        ,cGreen
 628                                                        ,cBlue
 629                                                       );
 630
 631             return (Create( rBitmap
 632                            ,vTransparentColour
 633                           ));
 634         }
 635     }
 636     return(FALSE);
 637 }
 638
 639 // Create a mask from a bitmap and a colour indicating
 640 // the transparent area
 641 bool wxMask::Create(
 642   const wxBitmap&                   rBitmap
 643 , const wxColour&                   rColour
 644 )
 645 {
 646     BITMAPINFOHEADER2               vHeader;
 647     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 648     SIZEL                           vSize = {0, 0};
 649     POINTL                          vPoint[4];
 650
 651     if (m_hMaskBitmap)
 652     {
 653         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
 654         m_hMaskBitmap = 0;
 655     }
 656     if (!rBitmap.Ok())
 657     {
 658         return(FALSE);
 659     }
 660
 661     // scan the bitmap for the transparent colour and set
 662     // the corresponding pixels in the mask to BLACK and
 663     // the rest to WHITE
 664     COLORREF                        vMaskColour = OS2RGB(rColour.Red(), rColour.Green(), rColour.Blue());
 665
 666     vHeader.cbFix           = sizeof(vHeader);
 667     vHeader.cx              = (USHORT)rBitmap.GetWidth();
 668     vHeader.cy              = (USHORT)rBitmap.GetHeight();
 669     vHeader.cPlanes         = 1;
 670     vHeader.cBitCount       = 1;
 671
 672     m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
 673                                                   ,&vHeader
 674                                                   ,0L
 675                                                   ,NULL
 676                                                   ,NULL
 677                                                  );
 678
 679     HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 680     ::GpiSetBitmap(srcPS, (HBITMAP)rBitmap.GetHBITMAP());
 681     HPS destPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 682     ::GpiSetBitmap(srcPS, (HBITMAP)m_hMaskBitmap);
 683
 684     // this is not very efficient, but I can't think
 685     // of a better way of doing it
 686     for (int w = 0; w < rBitmap.GetWidth(); w++)
 687     {
 688         for (int h = 0; h < rBitmap.GetHeight(); h++)
 689         {
 690             POINTL                  vPoint;
 691
 692             vPoint.x = w;
 693             vPoint.y = h;
 694
 695             COLORREF                col = ::GpiQueryPel(srcPS, &vPoint);
 696
 697             if (col == vMaskColour)
 698             {
 699                 ::GpiSetColor(destPS, CLR_WHITE);
 700                 ::GpiSetPel(destPS, &vPoint);
 701             }
 702             else
 703             {
 704                 ::GpiSetColor(destPS, CLR_BLACK);
 705                 ::GpiSetPel(destPS, &vPoint);
 706             }
 707         }
 708     }
 709     ::GpiDestroyPS(srcPS);
 710     ::GpiDestroyPS(destPS);
 711     return(TRUE);
 712 }
 713
 714 // ----------------------------------------------------------------------------
 715 // wxBitmapHandler
 716 // ----------------------------------------------------------------------------
 717
 718 bool wxBitmapHandler::Create(
 719   wxGDIImage*                       pImage
 720 , void*                             pData
 721 , long                              lFlags
 722 , int                               nWidth
 723 , int                               nHeight
 724 , int                               nDepth
 725 )
 726 {
 727     wxBitmap*                       pBitmap = wxDynamicCast( pImage
 728                                                             ,wxBitmap
 729                                                            );
 730
 731     return(pBitmap ? Create( pBitmap
 732                             ,pData
 733                             ,nWidth
 734                             ,nHeight
 735                             ,nDepth
 736                            ) : FALSE);
 737 }
 738
 739 bool wxBitmapHandler::Load(
 740   wxGDIImage*                       pImage
 741 , const wxString&                   rName
 742 , long                              lFlags
 743 , int                               nWidth
 744 , int                               nHeight
 745 )
 746 {
 747     wxBitmap*                       pBitmap = wxDynamicCast( pImage
 748                                                             ,wxBitmap
 749                                                            );
 750
 751     return(pBitmap ? LoadFile( pBitmap
 752                               ,rName
 753                               ,lFlags
 754                               ,nWidth
 755                               ,nHeight
 756                              ) : FALSE);
 757 }
 758
 759 bool wxBitmapHandler::Save(
 760   wxGDIImage*                       pImage
 761 , const wxString&                   rName
 762 , int                               lType
 763 )
 764 {
 765     wxBitmap*                       pBitmap = wxDynamicCast( pImage
 766                                                             ,wxBitmap
 767                                                            );
 768
 769     return(pBitmap ? SaveFile( pBitmap
 770                               ,rName
 771                               ,lType
 772                              ) : FALSE);
 773 }
 774
 775 bool wxBitmapHandler::Create(
 776   wxBitmap*                         WXUNUSED(pBitmap)
 777 , void*                             WXUNUSED(pData)
 778 , long                              WXUNUSED(lType)
 779 , int                               WXUNUSED(nWidth)
 780 , int                               WXUNUSED(nHeight)
 781 , int                               WXUNUSED(nDepth)
 782 )
 783 {
 784     return(FALSE);
 785 }
 786
 787 bool wxBitmapHandler::LoadFile(
 788   wxBitmap*                         WXUNUSED(pBitmap)
 789 , const wxString&                   WXUNUSED(rName)
 790 , long                              WXUNUSED(lType)
 791 , int                               WXUNUSED(nDesiredWidth)
 792 , int                               WXUNUSED(nDesiredHeight)
 793 )
 794 {
 795     return(FALSE);
 796 }
 797
 798 bool wxBitmapHandler::SaveFile(
 799   wxBitmap*                         WXUNUSED(pBitmap)
 800 , const wxString&                   WXUNUSED(rName)
 801 , int                               WXUNUSED(nType)
 802 , const wxPalette*                  WXUNUSED(pPalette)
 803 )
 804 {
 805     return(FALSE);
 806 }
 807