src/msw/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        bitmap.cpp
   3 // Purpose:     wxBitmap
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "bitmap.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include <stdio.h>
  33
  34     #include "wx/list.h"
  35     #include "wx/utils.h"
  36     #include "wx/app.h"
  37     #include "wx/palette.h"
  38     #include "wx/dcmemory.h"
  39     #include "wx/bitmap.h"
  40     #include "wx/icon.h"
  41 #endif
  42
  43 #include "wx/msw/private.h"
  44 #include "wx/log.h"
  45
  46 #include "wx/msw/dib.h"
  47 #include "wx/image.h"
  48
  49 // missing from mingw32 header
  50 #ifndef CLR_INVALID
  51     #define CLR_INVALID ((COLORREF)-1)
  52 #endif // no CLR_INVALID
  53
  54 // ----------------------------------------------------------------------------
  55 // macros
  56 // ----------------------------------------------------------------------------
  57
  58 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
  59 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  60
  61 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
  62
  63 // ============================================================================
  64 // implementation
  65 // ============================================================================
  66
  67 // ----------------------------------------------------------------------------
  68 // wxBitmapRefData
  69 // ----------------------------------------------------------------------------
  70
  71 wxBitmapRefData::wxBitmapRefData()
  72 {
  73     m_quality = 0;
  74     m_selectedInto = NULL;
  75     m_numColors = 0;
  76     m_bitmapMask = NULL;
  77     m_hBitmap = (WXHBITMAP) NULL;
  78 }
  79
  80 void wxBitmapRefData::Free()
  81 {
  82     wxASSERT_MSG( !m_selectedInto,
  83                   wxT("deleting bitmap still selected into wxMemoryDC") );
  84
  85     if ( m_hBitmap)
  86     {
  87         if ( !::DeleteObject((HBITMAP)m_hBitmap) )
  88         {
  89             wxLogLastError(wxT("DeleteObject(hbitmap)"));
  90         }
  91     }
  92
  93     delete m_bitmapMask;
  94     m_bitmapMask = NULL;
  95 }
  96
  97 // ----------------------------------------------------------------------------
  98 // wxBitmap creation
  99 // ----------------------------------------------------------------------------
 100
 101 // this function should be called from all wxBitmap ctors
 102 void wxBitmap::Init()
 103 {
 104     // m_refData = NULL; done in the base class ctor
 105
 106     if ( wxTheBitmapList )
 107         wxTheBitmapList->AddBitmap(this);
 108 }
 109
 110 #ifdef __WIN32__
 111
 112 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
 113 {
 114     // it may be either HICON or HCURSOR
 115     HICON hicon = (HICON)icon.GetHandle();
 116
 117     ICONINFO iconInfo;
 118     if ( !::GetIconInfo(hicon, &iconInfo) )
 119     {
 120         wxLogLastError(wxT("GetIconInfo"));
 121
 122         return FALSE;
 123     }
 124
 125     wxBitmapRefData *refData = new wxBitmapRefData;
 126     m_refData = refData;
 127
 128     int w = icon.GetWidth(),
 129         h = icon.GetHeight();
 130
 131     refData->m_width = w;
 132     refData->m_height = h;
 133     refData->m_depth = wxDisplayDepth();
 134
 135     refData->m_hBitmap = (WXHBITMAP)iconInfo.hbmColor;
 136
 137     // the mask returned by GetIconInfo() is inversed compared to the usual
 138     // wxWin convention
 139     refData->m_bitmapMask = new wxMask((WXHBITMAP)
 140                                         wxInvertMask(iconInfo.hbmMask, w, h));
 141
 142 #if WXWIN_COMPATIBILITY_2
 143     refData->m_ok = TRUE;
 144 #endif // WXWIN_COMPATIBILITY_2
 145
 146     return TRUE;
 147 }
 148
 149 #endif // Win32
 150
 151 bool wxBitmap::CopyFromCursor(const wxCursor& cursor)
 152 {
 153     UnRef();
 154
 155     if ( !cursor.Ok() )
 156         return FALSE;
 157
 158 #ifdef __WIN16__
 159     wxFAIL_MSG( _T("don't know how to convert cursor to bitmap") );
 160
 161     return FALSE;
 162 #else
 163     return CopyFromIconOrCursor(cursor);
 164 #endif // Win16
 165 }
 166
 167 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 168 {
 169     UnRef();
 170
 171     if ( !icon.Ok() )
 172         return FALSE;
 173
 174     // GetIconInfo() doesn't exist under Win16 and I don't know any other way
 175     // to create a bitmap from icon there - but using this way we won't have
 176     // the mask (FIXME)
 177 #ifdef __WIN16__
 178     int width = icon.GetWidth(),
 179         height = icon.GetHeight();
 180
 181     // copy the icon to the bitmap
 182     ScreenHDC hdcScreen;
 183     HDC hdc = ::CreateCompatibleDC(hdcScreen);
 184     HBITMAP hbitmap = ::CreateCompatibleBitmap(hdcScreen, width, height);
 185     HBITMAP hbmpOld = (HBITMAP)::SelectObject(hdc, hbitmap);
 186
 187     ::DrawIcon(hdc, 0, 0, GetHiconOf(icon));
 188
 189     ::SelectObject(hdc, hbmpOld);
 190     ::DeleteDC(hdc);
 191
 192     wxBitmapRefData *refData = new wxBitmapRefData;
 193     m_refData = refData;
 194
 195     refData->m_width = width;
 196     refData->m_height = height;
 197     refData->m_depth = wxDisplayDepth();
 198
 199     refData->m_hBitmap = (WXHBITMAP)hbitmap;
 200
 201 #if WXWIN_COMPATIBILITY_2
 202     refData->m_ok = TRUE;
 203 #endif // WXWIN_COMPATIBILITY_2
 204
 205     return TRUE;
 206 #else // Win32
 207     return CopyFromIconOrCursor(icon);
 208 #endif // Win16/Win32
 209 }
 210
 211 wxBitmap::~wxBitmap()
 212 {
 213     if (wxTheBitmapList)
 214         wxTheBitmapList->DeleteObject(this);
 215 }
 216
 217 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 218 {
 219     Init();
 220
 221     wxBitmapRefData *refData = new wxBitmapRefData;
 222     m_refData = refData;
 223
 224     refData->m_width = width;
 225     refData->m_height = height;
 226     refData->m_depth = depth;
 227     refData->m_numColors = 0;
 228     refData->m_selectedInto = NULL;
 229
 230     char *data;
 231     if ( depth == 1 )
 232     {
 233         // we assume that it is in XBM format which is not quite the same as
 234         // the format CreateBitmap() wants because the order of bytes in the
 235         // line is inversed!
 236         static const size_t bytesPerLine = (width + 7) / 8;
 237         static const size_t padding = bytesPerLine % 2;
 238         static const size_t len = height * ( padding + bytesPerLine );
 239         data = (char *)malloc(len);
 240         const char *src = bits;
 241         char *dst = data;
 242
 243         for ( int rows = 0; rows < height; rows++ )
 244         {
 245             for ( size_t cols = 0; cols < bytesPerLine; cols++ )
 246             {
 247                 unsigned char val = *src++;
 248                 unsigned char reversed = 0;
 249
 250                 for ( int bits = 0; bits < 8; bits++)
 251                 {
 252                     reversed <<= 1;
 253                     reversed |= (val & 0x01);
 254                     val >>= 1;
 255                 }
 256                 *dst++ = reversed;
 257             }
 258
 259             if ( padding )
 260                 *dst++ = 0;
 261         }
 262     }
 263     else
 264     {
 265         // bits should already be in Windows standard format
 266         data = (char *)bits;    // const_cast is harmless
 267     }
 268
 269     HBITMAP hbmp = ::CreateBitmap(width, height, 1, depth, data);
 270     if ( !hbmp )
 271     {
 272         wxLogLastError(wxT("CreateBitmap"));
 273     }
 274
 275     if ( data != bits )
 276     {
 277         free(data);
 278     }
 279
 280     SetHBITMAP((WXHBITMAP)hbmp);
 281 }
 282
 283 // Create from XPM data
 284 bool wxBitmap::CreateFromXpm(const char **data)
 285 {
 286     Init();
 287
 288     return Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
 289 }
 290
 291 wxBitmap::wxBitmap(int w, int h, int d)
 292 {
 293     Init();
 294
 295     (void)Create(w, h, d);
 296 }
 297
 298 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 299 {
 300     Init();
 301
 302     (void)Create(data, type, width, height, depth);
 303 }
 304
 305 wxBitmap::wxBitmap(const wxString& filename, long type)
 306 {
 307     Init();
 308
 309     LoadFile(filename, (int)type);
 310 }
 311
 312 bool wxBitmap::Create(int w, int h, int d)
 313 {
 314     UnRef();
 315
 316     m_refData = new wxBitmapRefData;
 317
 318     GetBitmapData()->m_width = w;
 319     GetBitmapData()->m_height = h;
 320     GetBitmapData()->m_depth = d;
 321
 322     HBITMAP hbmp;
 323
 324     if ( d > 0 )
 325     {
 326         hbmp = ::CreateBitmap(w, h, 1, d, NULL);
 327         if ( !hbmp )
 328         {
 329             wxLogLastError(wxT("CreateBitmap"));
 330         }
 331     }
 332     else
 333     {
 334         ScreenHDC dc;
 335         hbmp = ::CreateCompatibleBitmap(dc, w, h);
 336         if ( !hbmp )
 337         {
 338             wxLogLastError(wxT("CreateCompatibleBitmap"));
 339         }
 340
 341         GetBitmapData()->m_depth = wxDisplayDepth();
 342     }
 343
 344     SetHBITMAP((WXHBITMAP)hbmp);
 345
 346 #if WXWIN_COMPATIBILITY_2
 347     GetBitmapData()->m_ok = hbmp != 0;
 348 #endif // WXWIN_COMPATIBILITY_2
 349
 350     return Ok();
 351 }
 352
 353 bool wxBitmap::LoadFile(const wxString& filename, long type)
 354 {
 355     UnRef();
 356
 357     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 358
 359     if ( handler )
 360     {
 361         m_refData = new wxBitmapRefData;
 362
 363         return handler->LoadFile(this, filename, type, -1, -1);
 364     }
 365     else
 366     {
 367         wxImage image;
 368         if ( !image.LoadFile( filename, type ) || !image.Ok() )
 369             return FALSE;
 370
 371         *this = image.ConvertToBitmap();
 372
 373         return TRUE;
 374     }
 375 }
 376
 377 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 378 {
 379     UnRef();
 380
 381     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 382
 383     if ( !handler )
 384     {
 385         wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %d defined."), type);
 386
 387         return FALSE;
 388     }
 389
 390     m_refData = new wxBitmapRefData;
 391
 392     return handler->Create(this, data, type, width, height, depth);
 393 }
 394
 395 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 396 {
 397     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 398
 399     if ( handler )
 400     {
 401         return handler->SaveFile(this, filename, type, palette);
 402     }
 403     else
 404     {
 405         // FIXME what about palette? shouldn't we use it?
 406         wxImage image( *this );
 407         if (!image.Ok())
 408             return FALSE;
 409
 410         return image.SaveFile( filename, type );
 411     }
 412 }
 413
 414 // ----------------------------------------------------------------------------
 415 // sub bitmap extraction
 416 // ----------------------------------------------------------------------------
 417
 418 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 419 {
 420     wxCHECK_MSG( Ok() &&
 421                  (rect.x >= 0) && (rect.y >= 0) &&
 422                  (rect.x+rect.width <= GetWidth()) &&
 423                  (rect.y+rect.height <= GetHeight()),
 424                  wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
 425
 426     wxBitmap ret( rect.width, rect.height, GetDepth() );
 427     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 428
 429     // copy bitmap data
 430     HDC dcSrc = ::CreateCompatibleDC(NULL);
 431     HDC dcDst = ::CreateCompatibleDC(NULL);
 432     SelectObject(dcSrc, (HBITMAP) GetHBITMAP());
 433     SelectObject(dcDst, (HBITMAP) ret.GetHBITMAP());
 434     BitBlt(dcDst, 0, 0, rect.width, rect.height, dcSrc, rect.x, rect.y, SRCCOPY);
 435
 436     // copy mask if there is one
 437     if (GetMask())
 438     {
 439         HBITMAP hbmpMask = ::CreateBitmap(rect.width, rect.height, 1, 1, 0);
 440
 441         SelectObject(dcSrc, (HBITMAP) GetMask()->GetMaskBitmap());
 442         SelectObject(dcDst, (HBITMAP) hbmpMask);
 443         BitBlt(dcDst, 0, 0, rect.width, rect.height, dcSrc, rect.x, rect.y, SRCCOPY);
 444
 445         wxMask *mask = new wxMask((WXHBITMAP) hbmpMask);
 446         ret.SetMask(mask);
 447     }
 448
 449     SelectObject(dcDst, NULL);
 450     SelectObject(dcSrc, NULL);
 451     DeleteDC(dcDst);
 452     DeleteDC(dcSrc);
 453
 454     return ret;
 455 }
 456
 457 // ----------------------------------------------------------------------------
 458 // wxBitmap accessors
 459 // ----------------------------------------------------------------------------
 460
 461 void wxBitmap::SetQuality(int q)
 462 {
 463     EnsureHasData();
 464
 465     GetBitmapData()->m_quality = q;
 466 }
 467
 468 #if WXWIN_COMPATIBILITY_2
 469 void wxBitmap::SetOk(bool isOk)
 470 {
 471     EnsureHasData();
 472
 473     GetBitmapData()->m_ok = isOk;
 474 }
 475 #endif // WXWIN_COMPATIBILITY_2
 476
 477 void wxBitmap::SetPalette(const wxPalette& palette)
 478 {
 479     EnsureHasData();
 480
 481     GetBitmapData()->m_bitmapPalette = palette;
 482 }
 483
 484 void wxBitmap::SetMask(wxMask *mask)
 485 {
 486     EnsureHasData();
 487
 488     GetBitmapData()->m_bitmapMask = mask;
 489 }
 490
 491 // Creates a bitmap that matches the device context, from
 492 // an arbitray bitmap. At present, the original bitmap must have an
 493 // associated palette. TODO: use a default palette if no palette exists.
 494 // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
 495 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
 496 {
 497     wxMemoryDC      memDC;
 498     wxBitmap        tmpBitmap(GetWidth(), GetHeight(), dc.GetDepth());
 499     HPALETTE        hPal = (HPALETTE) NULL;
 500     LPBITMAPINFO    lpDib;
 501     void            *lpBits = (void*) NULL;
 502
 503     if( GetPalette() && GetPalette()->Ok() )
 504     {
 505         tmpBitmap.SetPalette(*GetPalette());
 506         memDC.SelectObject(tmpBitmap);
 507         memDC.SetPalette(*GetPalette());
 508         hPal = (HPALETTE)GetPalette()->GetHPALETTE();
 509     }
 510     else
 511     {
 512         hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
 513         wxPalette palette;
 514         palette.SetHPALETTE( (WXHPALETTE)hPal );
 515         tmpBitmap.SetPalette( palette );
 516         memDC.SelectObject(tmpBitmap);
 517         memDC.SetPalette( palette );
 518     }
 519
 520     // set the height negative because in a DIB the order of the lines is
 521     // reversed
 522     if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
 523     {
 524         return wxNullBitmap;
 525     }
 526
 527     lpBits = malloc(lpDib->bmiHeader.biSizeImage);
 528
 529     ::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits);
 530
 531     ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
 532                         GetWidth(), GetHeight(),
 533                         0, 0, 0, GetHeight(),
 534                         lpBits, lpDib, DIB_RGB_COLORS);
 535
 536     free(lpBits);
 537
 538     wxFreeDIB(lpDib);
 539
 540     return tmpBitmap;
 541 }
 542
 543 // ----------------------------------------------------------------------------
 544 // wxMask
 545 // ----------------------------------------------------------------------------
 546
 547 wxMask::wxMask()
 548 {
 549     m_maskBitmap = 0;
 550 }
 551
 552 // Construct a mask from a bitmap and a colour indicating
 553 // the transparent area
 554 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 555 {
 556     m_maskBitmap = 0;
 557     Create(bitmap, colour);
 558 }
 559
 560 // Construct a mask from a bitmap and a palette index indicating
 561 // the transparent area
 562 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 563 {
 564     m_maskBitmap = 0;
 565     Create(bitmap, paletteIndex);
 566 }
 567
 568 // Construct a mask from a mono bitmap (copies the bitmap).
 569 wxMask::wxMask(const wxBitmap& bitmap)
 570 {
 571     m_maskBitmap = 0;
 572     Create(bitmap);
 573 }
 574
 575 wxMask::~wxMask()
 576 {
 577     if ( m_maskBitmap )
 578         ::DeleteObject((HBITMAP) m_maskBitmap);
 579 }
 580
 581 // Create a mask from a mono bitmap (copies the bitmap).
 582 bool wxMask::Create(const wxBitmap& bitmap)
 583 {
 584     wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, FALSE,
 585                  _T("can't create mask from invalid or not monochrome bitmap") );
 586
 587     if ( m_maskBitmap )
 588     {
 589         ::DeleteObject((HBITMAP) m_maskBitmap);
 590         m_maskBitmap = 0;
 591     }
 592
 593     m_maskBitmap = (WXHBITMAP) CreateBitmap(
 594                                             bitmap.GetWidth(),
 595                                             bitmap.GetHeight(),
 596                                             1, 1, 0
 597                                            );
 598     HDC srcDC = CreateCompatibleDC(0);
 599     SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
 600     HDC destDC = CreateCompatibleDC(0);
 601     SelectObject(destDC, (HBITMAP) m_maskBitmap);
 602     BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
 603     SelectObject(srcDC, 0);
 604     DeleteDC(srcDC);
 605     SelectObject(destDC, 0);
 606     DeleteDC(destDC);
 607     return TRUE;
 608 }
 609
 610 // Create a mask from a bitmap and a palette index indicating
 611 // the transparent area
 612 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 613 {
 614     if ( m_maskBitmap )
 615     {
 616         ::DeleteObject((HBITMAP) m_maskBitmap);
 617         m_maskBitmap = 0;
 618     }
 619     if (bitmap.Ok() && bitmap.GetPalette()->Ok())
 620     {
 621         unsigned char red, green, blue;
 622         if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
 623         {
 624             wxColour transparentColour(red, green, blue);
 625             return Create(bitmap, transparentColour);
 626         }
 627     }
 628     return FALSE;
 629 }
 630
 631 // Create a mask from a bitmap and a colour indicating
 632 // the transparent area
 633 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 634 {
 635     wxCHECK_MSG( bitmap.Ok(), FALSE, _T("invalid bitmap in wxMask::Create") );
 636
 637     if ( m_maskBitmap )
 638     {
 639         ::DeleteObject((HBITMAP) m_maskBitmap);
 640         m_maskBitmap = 0;
 641     }
 642
 643     int width = bitmap.GetWidth(),
 644         height = bitmap.GetHeight();
 645
 646     // scan the bitmap for the transparent colour and set the corresponding
 647     // pixels in the mask to BLACK and the rest to WHITE
 648     COLORREF maskColour = wxColourToRGB(colour);
 649     m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0);
 650
 651     HDC srcDC = ::CreateCompatibleDC(NULL);
 652     HDC destDC = ::CreateCompatibleDC(NULL);
 653     if ( !srcDC || !destDC )
 654     {
 655         wxLogLastError(wxT("CreateCompatibleDC"));
 656     }
 657
 658     bool ok = TRUE;
 659
 660     HGDIOBJ hbmpSrcOld = ::SelectObject(srcDC, GetHbitmapOf(bitmap));
 661     if ( !hbmpSrcOld )
 662     {
 663         wxLogLastError(wxT("SelectObject"));
 664
 665         ok = FALSE;
 666     }
 667
 668     HGDIOBJ hbmpDstOld = ::SelectObject(destDC, (HBITMAP)m_maskBitmap);
 669     if ( !hbmpDstOld )
 670     {
 671         wxLogLastError(wxT("SelectObject"));
 672
 673         ok = FALSE;
 674     }
 675
 676     // this is not very efficient, but I can't think of a better way of doing
 677     // it
 678     for ( int w = 0; ok && (w < width); w++ )
 679     {
 680         for ( int h = 0; ok && (h < height); h++ )
 681         {
 682             COLORREF col = GetPixel(srcDC, w, h);
 683             if ( col == CLR_INVALID )
 684             {
 685                 wxLogLastError(wxT("GetPixel"));
 686
 687                 // doesn't make sense to continue
 688                 ok = FALSE;
 689
 690                 break;
 691             }
 692
 693             if ( col == maskColour )
 694             {
 695                 ::SetPixel(destDC, w, h, RGB(0, 0, 0));
 696             }
 697             else
 698             {
 699                 ::SetPixel(destDC, w, h, RGB(255, 255, 255));
 700             }
 701         }
 702     }
 703
 704     ::SelectObject(srcDC, hbmpSrcOld);
 705     ::DeleteDC(srcDC);
 706     ::SelectObject(destDC, hbmpDstOld);
 707     ::DeleteDC(destDC);
 708
 709     return ok;
 710 }
 711
 712 // ----------------------------------------------------------------------------
 713 // wxBitmapHandler
 714 // ----------------------------------------------------------------------------
 715
 716 bool wxBitmapHandler::Create(wxGDIImage *image,
 717                              void *data,
 718                              long flags,
 719                              int width, int height, int depth)
 720 {
 721     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 722
 723     return bitmap ? Create(bitmap, data, width, height, depth) : FALSE;
 724 }
 725
 726 bool wxBitmapHandler::Load(wxGDIImage *image,
 727                            const wxString& name,
 728                            long flags,
 729                            int width, int height)
 730 {
 731     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 732
 733     return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE;
 734 }
 735
 736 bool wxBitmapHandler::Save(wxGDIImage *image,
 737                            const wxString& name,
 738                            int type)
 739 {
 740     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 741
 742     return bitmap ? SaveFile(bitmap, name, type) : FALSE;
 743 }
 744
 745 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
 746                              void *WXUNUSED(data),
 747                              long WXUNUSED(type),
 748                              int WXUNUSED(width),
 749                              int WXUNUSED(height),
 750                              int WXUNUSED(depth))
 751 {
 752     return FALSE;
 753 }
 754
 755 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
 756                                const wxString& WXUNUSED(name),
 757                                long WXUNUSED(type),
 758                                int WXUNUSED(desiredWidth),
 759                                int WXUNUSED(desiredHeight))
 760 {
 761     return FALSE;
 762 }
 763
 764 bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
 765                                const wxString& WXUNUSED(name),
 766                                int WXUNUSED(type),
 767                                const wxPalette *WXUNUSED(palette))
 768 {
 769     return FALSE;
 770 }
 771
 772 // ----------------------------------------------------------------------------
 773 // DIB functions
 774 // ----------------------------------------------------------------------------
 775
 776 bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
 777                  HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
 778 {
 779    unsigned long   i, headerSize;
 780    LPBITMAPINFO    lpDIBheader = NULL;
 781    LPPALETTEENTRY  lpPe = NULL;
 782
 783
 784    // Allocate space for a DIB header
 785    headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
 786    lpDIBheader = (BITMAPINFO *) malloc(headerSize);
 787    lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
 788
 789    GetPaletteEntries(hPal, 0, 256, lpPe);
 790
 791    memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
 792
 793    // Fill in the static parts of the DIB header
 794    lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 795    lpDIBheader->bmiHeader.biWidth = xSize;
 796    lpDIBheader->bmiHeader.biHeight = ySize;
 797    lpDIBheader->bmiHeader.biPlanes = 1;
 798
 799    // this value must be 1, 4, 8 or 24 so PixelDepth can only be
 800    lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
 801    lpDIBheader->bmiHeader.biCompression = BI_RGB;
 802    lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3;
 803    lpDIBheader->bmiHeader.biClrUsed = 256;
 804
 805
 806    // Initialize the DIB palette
 807    for (i = 0; i < 256; i++) {
 808       lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
 809       lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
 810       lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
 811       lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
 812    }
 813
 814    *lpDIBHeader = lpDIBheader;
 815
 816    return TRUE;
 817 }
 818
 819 void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
 820 {
 821     free(lpDIBHeader);
 822 }
 823
 824 // ----------------------------------------------------------------------------
 825 // other helper functions
 826 // ----------------------------------------------------------------------------
 827
 828 extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h)
 829 {
 830     wxCHECK_MSG( hbmpMask, 0, _T("invalid bitmap in wxInvertMask") );
 831
 832     // get width/height from the bitmap if not given
 833     if ( !w || !h )
 834     {
 835         BITMAP bm;
 836         ::GetObject(hbmpMask, sizeof(BITMAP), (LPVOID)&bm);
 837         w = bm.bmWidth;
 838         h = bm.bmHeight;
 839     }
 840
 841     HDC hdcSrc = ::CreateCompatibleDC(NULL);
 842     HDC hdcDst = ::CreateCompatibleDC(NULL);
 843     if ( !hdcSrc || !hdcDst )
 844     {
 845         wxLogLastError(wxT("CreateCompatibleDC"));
 846     }
 847
 848     HBITMAP hbmpInvMask = ::CreateBitmap(w, h, 1, 1, 0);
 849     if ( !hbmpInvMask )
 850     {
 851         wxLogLastError(wxT("CreateBitmap"));
 852     }
 853
 854     ::SelectObject(hdcSrc, hbmpMask);
 855     ::SelectObject(hdcDst, hbmpInvMask);
 856     if ( !::BitBlt(hdcDst, 0, 0, w, h,
 857                    hdcSrc, 0, 0,
 858                    NOTSRCCOPY) )
 859     {
 860         wxLogLastError(wxT("BitBlt"));
 861     }
 862
 863     ::DeleteDC(hdcSrc);
 864     ::DeleteDC(hdcDst);
 865
 866     return hbmpInvMask;
 867 }