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