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_hDc = hDc;
 189     m_hPs = hPs;
 190
 191     m_refData = pRefData;
 192
 193     pRefData->m_nWidth = nTheWidth;
 194     pRefData->m_nHeight = nTheHeight;
 195     pRefData->m_nDepth = nNoBits;
 196     pRefData->m_nNumColors = 0;
 197     pRefData->m_pSelectedInto = NULL;
 198
 199     HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
 200     if (!hBmp)
 201     {
 202         wxLogLastError("CreateBitmap");
 203     }
 204     SetHBITMAP((WXHBITMAP)hBmp);
 205 }
 206
 207 // Create from XPM data
 208 wxBitmap::wxBitmap(
 209   char**                            ppData
 210 , wxControl*                        WXUNUSED(pAnItem))
 211 {
 212     Init();
 213
 214     (void)Create( (void *)ppData
 215                  ,wxBITMAP_TYPE_XPM_DATA
 216                  ,0
 217                  ,0
 218                  ,0
 219                 );
 220 }
 221
 222 wxBitmap::wxBitmap(
 223   int                               nW
 224 , int                               nH
 225 , int                               nD
 226 )
 227 {
 228     Init();
 229
 230     (void)Create( nW
 231                  ,nH
 232                  ,nD
 233                 );
 234 }
 235
 236 wxBitmap::wxBitmap(
 237   void*                             pData
 238 , long                              lType
 239 , int                               nWidth
 240 , int                               nHeight
 241 , int                               nDepth
 242 )
 243 {
 244     Init();
 245
 246     (void)Create( pData
 247                  ,lType
 248                  ,nWidth
 249                  ,nHeight
 250                  ,nDepth
 251                 );
 252 }
 253
 254 wxBitmap::wxBitmap(
 255   const wxString&                   rFilename
 256 , long                              lType
 257 )
 258 {
 259     Init();
 260
 261     LoadFile( rFilename
 262              ,(int)lType
 263             );
 264 }
 265
 266 bool wxBitmap::Create(
 267   int                               nW
 268 , int                               nH
 269 , int                               nD
 270 )
 271 {
 272     HBITMAP                         hBmp;
 273     BITMAPINFOHEADER2               vHeader;
 274     BITMAPINFO2                     vInfo;
 275     HPS                             hpsScreen;
 276     HDC                             hdcScreen;
 277     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 278     SIZEL                           vSize = {0, 0};
 279     LONG                            lBitCount;
 280
 281     wxASSERT(vHabmain != NULL);
 282
 283     hpsScreen = ::WinGetScreenPS(HWND_DESKTOP);
 284     hdcScreen = ::GpiQueryDevice(hpsScreen);
 285     ::DevQueryCaps(hdcScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
 286
 287     vHeader.cbFix           = sizeof(vHeader);
 288     vHeader.cx              = (USHORT)nW;
 289     vHeader.cy              = (USHORT)nH;
 290     vHeader.cPlanes         = (USHORT)nD;
 291     vHeader.cBitCount       = lBitCount;
 292     vHeader.ulCompression   = BCA_UNCOMP;
 293     vHeader.cxResolution    = 0;
 294     vHeader.cyResolution    = 0;
 295     vHeader.cclrUsed        = 0;
 296     vHeader.cclrImportant   = 0;
 297     vHeader.usUnits         = BRU_METRIC;
 298     vHeader.usRecording     = BRA_BOTTOMUP;
 299     vHeader.usRendering     = BRH_NOTHALFTONED;
 300     vHeader.cSize1          = 0;
 301     vHeader.cSize2          = 0;
 302     vHeader.ulColorEncoding = 0;
 303     vHeader.ulIdentifier    = 0;
 304
 305     UnRef();
 306     m_refData = new wxBitmapRefData;
 307
 308     GetBitmapData()->m_nWidth = nW;
 309     GetBitmapData()->m_nHeight = nH;
 310     GetBitmapData()->m_nDepth = nD;
 311
 312     if (nD > 0)
 313     {
 314         hBmp = ::GpiCreateBitmap(hpsScreen, &vHeader, 0L, NULL, &vInfo);
 315         if (!hBmp)
 316         {
 317             wxLogLastError("CreateBitmap");
 318         }
 319     }
 320     else
 321     {
 322         LONG                            lPlanes;
 323
 324         ::DevQueryCaps(hdcScreen, CAPS_COLOR_PLANES, 1L, &lPlanes);
 325         hBmp = ::GpiCreateBitmap(hpsScreen, &vHeader, 0L, NULL, &vInfo);
 326         if (!hBmp)
 327         {
 328             wxLogLastError("CreateBitmap");
 329         }
 330         GetBitmapData()->m_nDepth = wxDisplayDepth();
 331     }
 332     SetHBITMAP((WXHBITMAP)hBmp);
 333
 334 #if WXWIN_COMPATIBILITY_2
 335     GetBitmapData()->m_bOk = hBmp != 0;
 336 #endif // WXWIN_COMPATIBILITY_2
 337
 338     return Ok();
 339 }
 340
 341 bool wxBitmap::LoadFile(
 342   const wxString&                   rFilename
 343 , long                              lType
 344 )
 345 {
 346     UnRef();
 347
 348     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 349                                                              ,wxBitmapHandler
 350                                                             );
 351
 352     if (pHandler)
 353     {
 354         m_refData = new wxBitmapRefData;
 355
 356         return(pHandler->LoadFile( this
 357                                   ,rFilename
 358                                   ,lType
 359                                   , -1
 360                                   , -1
 361                                  ));
 362     }
 363     else
 364     {
 365         wxImage                     vImage;
 366
 367         if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
 368             return(FALSE);
 369
 370         *this = vImage.ConvertToBitmap();
 371
 372         return(TRUE);
 373     }
 374 }
 375
 376 bool wxBitmap::Create(
 377   void*                             pData
 378 , long                              lType
 379 , int                               nWidth
 380 , int                               nHeight
 381 , int                               nDepth
 382 )
 383 {
 384     UnRef();
 385
 386     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 387                                                              ,wxBitmapHandler
 388                                                             );
 389
 390     if (!pHandler)
 391     {
 392         wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
 393                        "type %d defined."), lType);
 394
 395         return(FALSE);
 396     }
 397
 398     m_refData = new wxBitmapRefData;
 399
 400     return(pHandler->Create( this
 401                             ,pData
 402                             ,lType
 403                             ,nWidth
 404                             ,nHeight
 405                             ,nDepth
 406                            ));
 407 }
 408
 409 bool wxBitmap::SaveFile(
 410   const wxString&                   rFilename
 411 , int                               lType
 412 , const wxPalette*                  pPalette
 413 )
 414 {
 415     wxBitmapHandler*                pHandler = wxDynamicCast( FindHandler(lType)
 416                                                              ,wxBitmapHandler
 417                                                             );
 418
 419     if (pHandler)
 420     {
 421         return pHandler->SaveFile( this
 422                                   ,rFilename
 423                                   ,lType
 424                                   ,pPalette
 425                                  );
 426     }
 427     else
 428     {
 429         // FIXME what about palette? shouldn't we use it?
 430         wxImage                     vImage(*this);
 431
 432         if (!vImage.Ok())
 433             return(FALSE);
 434
 435         return(vImage.SaveFile( rFilename
 436                                ,lType
 437                               ));
 438     }
 439 }
 440
 441 // ----------------------------------------------------------------------------
 442 // wxBitmap accessors
 443 // ----------------------------------------------------------------------------
 444
 445 void wxBitmap::SetQuality(
 446   int                               nQ
 447 )
 448 {
 449     EnsureHasData();
 450
 451     GetBitmapData()->m_nQuality = nQ;
 452 }
 453
 454 #if WXWIN_COMPATIBILITY_2
 455 void wxBitmap::SetOk(
 456   bool                              bOk
 457 )
 458 {
 459     EnsureHasData();
 460
 461     GetBitmapData()->m_bOk = bOk;
 462 }
 463 #endif // WXWIN_COMPATIBILITY_2
 464
 465 void wxBitmap::SetPalette(
 466   const wxPalette&                  rPalette
 467 )
 468 {
 469     EnsureHasData();
 470
 471     GetBitmapData()->m_vBitmapPalette = rPalette;
 472 }
 473
 474 void wxBitmap::SetMask(
 475   wxMask*                           pMask
 476 )
 477 {
 478     EnsureHasData();
 479
 480     GetBitmapData()->m_pBitmapMask = pMask;
 481 }
 482
 483 // Will try something for OS/2 but not really sure how close
 484 // to the msw intent this is.
 485 wxBitmap wxBitmap::GetBitmapForDC(
 486   wxDC&                             rDc
 487 ) const
 488 {
 489     wxMemoryDC                      vMemDC;
 490     wxBitmap                        vTmpBitmap( this->GetWidth()
 491                                                ,this->GetHeight()
 492                                                ,rDc.GetDepth()
 493                                               );
 494     WXHBITMAP                       vOldBitmap;
 495     HPS                             hMemoryPS;
 496     HPS                             hPs;
 497     POINTL                          vPoint[4];
 498     SIZEL                           vSize = {0,0};
 499
 500     hMemoryPS = ::GpiCreatePS(vHabmain, (HDC)vMemDC.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 501     hPs       = ::GpiCreatePS(vHabmain, (HDC)rDc.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 502
 503     // TODO: Set the points
 504
 505     vOldBitmap = (WXHBITMAP)::GpiSetBitmap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
 506     ::GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY, BBO_IGNORE);
 507
 508     return(vTmpBitmap);
 509 }
 510
 511 // ----------------------------------------------------------------------------
 512 // wxMask
 513 // ----------------------------------------------------------------------------
 514
 515 wxMask::wxMask()
 516 {
 517     m_hMaskBitmap = 0;
 518 }
 519
 520 // Construct a mask from a bitmap and a colour indicating
 521 // the transparent area
 522 wxMask::wxMask(
 523   const wxBitmap&                   rBitmap
 524 , const wxColour&                   rColour
 525 )
 526 {
 527     m_hMaskBitmap = 0;
 528     Create( rBitmap
 529            ,rColour
 530           );
 531 }
 532
 533 // Construct a mask from a bitmap and a palette index indicating
 534 // the transparent area
 535 wxMask::wxMask(
 536   const wxBitmap&                   rBitmap
 537 , int                               nPaletteIndex
 538 )
 539 {
 540     m_hMaskBitmap = 0;
 541     Create( rBitmap
 542            ,nPaletteIndex
 543           );
 544 }
 545
 546 // Construct a mask from a mono bitmap (copies the bitmap).
 547 wxMask::wxMask(
 548   const wxBitmap&                   rBitmap
 549 )
 550 {
 551     m_hMaskBitmap = 0;
 552     Create(rBitmap);
 553 }
 554
 555 wxMask::~wxMask()
 556 {
 557     if (m_hMaskBitmap)
 558         ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
 559 }
 560
 561 // Create a mask from a mono bitmap (copies the bitmap).
 562 bool wxMask::Create(
 563   const wxBitmap&                   rBitmap
 564 )
 565 {
 566     BITMAPINFOHEADER2               vHeader;
 567     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 568     SIZEL                           vSize = {0, 0};
 569     POINTL                          vPoint[4];
 570
 571     if (m_hMaskBitmap)
 572     {
 573         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
 574         m_hMaskBitmap = 0;
 575     }
 576     if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
 577     {
 578         return(FALSE);
 579     }
 580     vHeader.cbFix           = sizeof(vHeader);
 581     vHeader.cx              = (USHORT)rBitmap.GetWidth();
 582     vHeader.cy              = (USHORT)rBitmap.GetHeight();
 583     vHeader.cPlanes         = 1;
 584     vHeader.cBitCount       = 1;
 585
 586     m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
 587                                                   ,&vHeader
 588                                                   ,0L
 589                                                   ,NULL
 590                                                   ,NULL
 591                                                  );
 592
 593     HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 594     ::GpiSetBitmap(srcPS, (HBITMAP)rBitmap.GetHBITMAP());
 595     HPS destPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 596     ::GpiSetBitmap(srcPS, (HBITMAP)m_hMaskBitmap);
 597     // TODO: Set the point array
 598     ::GpiBitBlt(destPS, srcPS, 4L, vPoint, ROP_SRCCOPY , BBO_IGNORE);
 599
 600     ::GpiDestroyPS(srcPS);
 601     ::GpiDestroyPS(destPS);
 602     return(TRUE);
 603 }
 604
 605 // Create a mask from a bitmap and a palette index indicating
 606 // the transparent area
 607 bool wxMask::Create(
 608   const wxBitmap&                   rBitmap
 609 , int                               nPaletteIndex
 610 )
 611 {
 612     if (m_hMaskBitmap)
 613     {
 614         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
 615         m_hMaskBitmap = 0;
 616     }
 617     if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
 618     {
 619         unsigned char               cRed;
 620         unsigned char               cGreen;
 621         unsigned char               cBlue;
 622
 623         if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
 624                                          ,&cRed
 625                                          ,&cGreen
 626                                          ,&cBlue
 627                                         ))
 628         {
 629             wxColour                vTransparentColour( cRed
 630                                                        ,cGreen
 631                                                        ,cBlue
 632                                                       );
 633
 634             return (Create( rBitmap
 635                            ,vTransparentColour
 636                           ));
 637         }
 638     }
 639     return(FALSE);
 640 }
 641
 642 // Create a mask from a bitmap and a colour indicating
 643 // the transparent area
 644 bool wxMask::Create(
 645   const wxBitmap&                   rBitmap
 646 , const wxColour&                   rColour
 647 )
 648 {
 649     BITMAPINFOHEADER2               vHeader;
 650     DEVOPENSTRUC                    vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 651     SIZEL                           vSize = {0, 0};
 652     POINTL                          vPoint[4];
 653
 654     if (m_hMaskBitmap)
 655     {
 656         ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
 657         m_hMaskBitmap = 0;
 658     }
 659     if (!rBitmap.Ok())
 660     {
 661         return(FALSE);
 662     }
 663
 664     // scan the bitmap for the transparent colour and set
 665     // the corresponding pixels in the mask to BLACK and
 666     // the rest to WHITE
 667     COLORREF                        vMaskColour = OS2RGB(rColour.Red(), rColour.Green(), rColour.Blue());
 668
 669     vHeader.cbFix           = sizeof(vHeader);
 670     vHeader.cx              = (USHORT)rBitmap.GetWidth();
 671     vHeader.cy              = (USHORT)rBitmap.GetHeight();
 672     vHeader.cPlanes         = 1;
 673     vHeader.cBitCount       = 1;
 674
 675     m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
 676                                                   ,&vHeader
 677                                                   ,0L
 678                                                   ,NULL
 679                                                   ,NULL
 680                                                  );
 681
 682     HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 683     ::GpiSetBitmap(srcPS, (HBITMAP)rBitmap.GetHBITMAP());
 684     HPS destPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 685     ::GpiSetBitmap(srcPS, (HBITMAP)m_hMaskBitmap);
 686
 687     // this is not very efficient, but I can't think
 688     // of a better way of doing it
 689     for (int w = 0; w < rBitmap.GetWidth(); w++)
 690     {
 691         for (int h = 0; h < rBitmap.GetHeight(); h++)
 692         {
 693             POINTL                  vPoint;
 694
 695             vPoint.x = w;
 696             vPoint.y = h;
 697
 698             COLORREF                col = ::GpiQueryPel(srcPS, &vPoint);
 699
 700             if (col == vMaskColour)
 701             {
 702                 ::GpiSetColor(destPS, CLR_WHITE);
 703                 ::GpiSetPel(destPS, &vPoint);
 704             }
 705             else
 706             {
 707                 ::GpiSetColor(destPS, CLR_BLACK);
 708                 ::GpiSetPel(destPS, &vPoint);
 709             }
 710         }
 711     }
 712     ::GpiDestroyPS(srcPS);
 713     ::GpiDestroyPS(destPS);
 714     return(TRUE);
 715 }
 716
 717 // ----------------------------------------------------------------------------
 718 // wxBitmapHandler
 719 // ----------------------------------------------------------------------------
 720
 721 bool wxBitmapHandler::Create(
 722   wxGDIImage*                       pImage
 723 , void*                             pData
 724 , long                              lFlags
 725 , int                               nWidth
 726 , int                               nHeight
 727 , int                               nDepth
 728 )
 729 {
 730     wxBitmap*                       pBitmap = wxDynamicCast( pImage
 731                                                             ,wxBitmap
 732                                                            );
 733
 734     return(pBitmap ? Create( pBitmap
 735                             ,pData
 736                             ,nWidth
 737                             ,nHeight
 738                             ,nDepth
 739                            ) : FALSE);
 740 }
 741
 742 bool wxBitmapHandler::Load(
 743   wxGDIImage*                       pImage
 744 , const wxString&                   rName
 745 , long                              lFlags
 746 , int                               nWidth
 747 , int                               nHeight
 748 )
 749 {
 750     wxBitmap*                       pBitmap = wxDynamicCast( pImage
 751                                                             ,wxBitmap
 752                                                            );
 753
 754     return(pBitmap ? LoadFile( pBitmap
 755                               ,rName
 756                               ,lFlags
 757                               ,nWidth
 758                               ,nHeight
 759                              ) : FALSE);
 760 }
 761
 762 bool wxBitmapHandler::Save(
 763   wxGDIImage*                       pImage
 764 , const wxString&                   rName
 765 , int                               lType
 766 )
 767 {
 768     wxBitmap*                       pBitmap = wxDynamicCast( pImage
 769                                                             ,wxBitmap
 770                                                            );
 771
 772     return(pBitmap ? SaveFile( pBitmap
 773                               ,rName
 774                               ,lType
 775                              ) : FALSE);
 776 }
 777
 778 bool wxBitmapHandler::Create(
 779   wxBitmap*                         WXUNUSED(pBitmap)
 780 , void*                             WXUNUSED(pData)
 781 , long                              WXUNUSED(lType)
 782 , int                               WXUNUSED(nWidth)
 783 , int                               WXUNUSED(nHeight)
 784 , int                               WXUNUSED(nDepth)
 785 )
 786 {
 787     return(FALSE);
 788 }
 789
 790 bool wxBitmapHandler::LoadFile(
 791   wxBitmap*                         WXUNUSED(pBitmap)
 792 , const wxString&                   WXUNUSED(rName)
 793 , long                              WXUNUSED(lType)
 794 , int                               WXUNUSED(nDesiredWidth)
 795 , int                               WXUNUSED(nDesiredHeight)
 796 )
 797 {
 798     return(FALSE);
 799 }
 800
 801 bool wxBitmapHandler::SaveFile(
 802   wxBitmap*                         WXUNUSED(pBitmap)
 803 , const wxString&                   WXUNUSED(rName)
 804 , int                               WXUNUSED(nType)
 805 , const wxPalette*                  WXUNUSED(pPalette)
 806 )
 807 {
 808     return(FALSE);
 809 }
 810