src/msw/bitmap.cpp

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/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
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/bitmap.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include <stdio.h>
  31
  32     #include "wx/list.h"
  33     #include "wx/utils.h"
  34     #include "wx/app.h"
  35     #include "wx/palette.h"
  36     #include "wx/dcmemory.h"
  37     #include "wx/icon.h"
  38     #include "wx/log.h"
  39     #include "wx/image.h"
  40 #endif
  41
  42 #include "wx/msw/private.h"
  43
  44 #if wxUSE_WXDIB
  45     #include "wx/msw/dib.h"
  46 #endif
  47
  48 #include "wx/xpmdecod.h"
  49
  50 #ifdef wxHAVE_RAW_BITMAP
  51     #include "wx/rawbmp.h"
  52 #endif
  53
  54 // missing from mingw32 header
  55 #ifndef CLR_INVALID
  56     #define CLR_INVALID ((COLORREF)-1)
  57 #endif // no CLR_INVALID
  58
  59 // ----------------------------------------------------------------------------
  60 // Bitmap data
  61 // ----------------------------------------------------------------------------
  62
  63 class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData
  64 {
  65 public:
  66     wxBitmapRefData();
  67     wxBitmapRefData(const wxBitmapRefData& data);
  68     virtual ~wxBitmapRefData() { Free(); }
  69
  70     virtual void Free();
  71
  72     // set the mask object to use as the mask, we take ownership of it
  73     void SetMask(wxMask *mask)
  74     {
  75         delete m_bitmapMask;
  76         m_bitmapMask = mask;
  77     }
  78
  79     // set the HBITMAP to use as the mask
  80     void SetMask(HBITMAP hbmpMask)
  81     {
  82         SetMask(new wxMask((WXHBITMAP)hbmpMask));
  83     }
  84
  85     // return the mask
  86     wxMask *GetMask() const { return m_bitmapMask; }
  87
  88 public:
  89 #if wxUSE_PALETTE
  90     wxPalette     m_bitmapPalette;
  91 #endif // wxUSE_PALETTE
  92
  93     // MSW-specific
  94     // ------------
  95
  96 #ifdef __WXDEBUG__
  97     // this field is solely for error checking: we detect selecting a bitmap
  98     // into more than one DC at once or deleting a bitmap still selected into a
  99     // DC (both are serious programming errors under Windows)
 100     wxDC         *m_selectedInto;
 101 #endif // __WXDEBUG__
 102
 103 #if wxUSE_WXDIB
 104     // when GetRawData() is called for a DDB we need to convert it to a DIB
 105     // first to be able to provide direct access to it and we cache that DIB
 106     // here and convert it back to DDB when UngetRawData() is called
 107     wxDIB *m_dib;
 108 #endif
 109
 110     // true if we have alpha transparency info and can be drawn using
 111     // AlphaBlend()
 112     bool m_hasAlpha;
 113
 114     // true if our HBITMAP is a DIB section, false if it is a DDB
 115     bool m_isDIB;
 116
 117 private:
 118     // optional mask for transparent drawing
 119     wxMask       *m_bitmapMask;
 120
 121
 122     // not implemented
 123     wxBitmapRefData& operator=(const wxBitmapRefData&);
 124 };
 125
 126 // ----------------------------------------------------------------------------
 127 // macros
 128 // ----------------------------------------------------------------------------
 129
 130 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 131 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 132
 133 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 134
 135 // ============================================================================
 136 // implementation
 137 // ============================================================================
 138
 139 // ----------------------------------------------------------------------------
 140 // helper functions
 141 // ----------------------------------------------------------------------------
 142
 143 // decide whether we should create a DIB or a DDB for the given parameters
 144 //
 145 // NB: we always use DIBs under Windows CE as this is much simpler (even if
 146 //     also less efficient...) and we obviously can't use them if there is no
 147 //     DIB support compiled in at all
 148 #ifdef __WXWINCE__
 149     static inline bool wxShouldCreateDIB(int, int, int, WXHDC) { return true; }
 150
 151     #define ALWAYS_USE_DIB
 152 #elif !wxUSE_WXDIB
 153     // no sense in defining wxShouldCreateDIB() as we can't compile code
 154     // executed if it is true, so we have to use #if's anyhow
 155     #define NEVER_USE_DIB
 156 #else // wxUSE_WXDIB && !__WXWINCE__
 157     static inline bool wxShouldCreateDIB(int w, int h, int d, WXHDC hdc)
 158     {
 159         // here is the logic:
 160         //
 161         //  (a) if hdc is specified, the caller explicitly wants DDB
 162         //  (b) otherwise, create a DIB if depth >= 24 (we don't support 16bpp
 163         //      or less DIBs anyhow)
 164         //  (c) finally, create DIBs under Win9x even if the depth hasn't been
 165         //      explicitly specified but the current display depth is 24 or
 166         //      more and the image is "big", i.e. > 16Mb which is the
 167         //      theoretical limit for DDBs under Win9x
 168         //
 169         // consequences (all of which seem to make sense):
 170         //
 171         //  (i)     by default, DDBs are created (depth == -1 usually)
 172         //  (ii)    DIBs can be created by explicitly specifying the depth
 173         //  (iii)   using a DC always forces creating a DDB
 174         return !hdc &&
 175                 (d >= 24 ||
 176                     (d == -1 &&
 177                         wxDIB::GetLineSize(w, wxDisplayDepth())*h > 16*1024*1024));
 178     }
 179
 180     #define SOMETIMES_USE_DIB
 181 #endif // different DIB usage scenarious
 182
 183 // ----------------------------------------------------------------------------
 184 // wxBitmapRefData
 185 // ----------------------------------------------------------------------------
 186
 187 wxBitmapRefData::wxBitmapRefData()
 188 {
 189 #ifdef __WXDEBUG__
 190     m_selectedInto = NULL;
 191 #endif
 192     m_bitmapMask = NULL;
 193
 194     m_hBitmap = (WXHBITMAP) NULL;
 195 #if wxUSE_WXDIB
 196     m_dib = NULL;
 197 #endif
 198
 199     m_isDIB =
 200     m_hasAlpha = false;
 201 }
 202
 203 wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData& data)
 204                : wxGDIImageRefData(data)
 205 {
 206 #ifdef __WXDEBUG__
 207     m_selectedInto = NULL;
 208 #endif
 209
 210     // can't copy the mask as the other bitmap destroys it
 211     m_bitmapMask = NULL;
 212
 213     wxASSERT_MSG( !data.m_isDIB,
 214                     _T("can't copy bitmap locked for raw access!") );
 215     m_isDIB = false;
 216
 217     m_hasAlpha = data.m_hasAlpha;
 218 }
 219
 220 void wxBitmapRefData::Free()
 221 {
 222     wxASSERT_MSG( !m_selectedInto,
 223                   wxT("deleting bitmap still selected into wxMemoryDC") );
 224
 225 #if wxUSE_WXDIB
 226     wxASSERT_MSG( !m_dib, _T("forgot to call wxBitmap::UngetRawData()!") );
 227 #endif
 228
 229     if ( m_hBitmap)
 230     {
 231         if ( !::DeleteObject((HBITMAP)m_hBitmap) )
 232         {
 233             wxLogLastError(wxT("DeleteObject(hbitmap)"));
 234         }
 235     }
 236
 237     delete m_bitmapMask;
 238     m_bitmapMask = NULL;
 239 }
 240
 241 // ----------------------------------------------------------------------------
 242 // wxBitmap creation
 243 // ----------------------------------------------------------------------------
 244
 245 wxGDIImageRefData *wxBitmap::CreateData() const
 246 {
 247     return new wxBitmapRefData;
 248 }
 249
 250 wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *dataOrig) const
 251 {
 252     const wxBitmapRefData *
 253         data = wx_static_cast(const wxBitmapRefData *, dataOrig);
 254     if ( !data )
 255         return NULL;
 256
 257     wxBitmap *self = wx_const_cast(wxBitmap *, this);
 258
 259 #if wxUSE_WXDIB
 260     // copy the other bitmap
 261     if ( data->m_hBitmap )
 262     {
 263         wxDIB dib((HBITMAP)(data->m_hBitmap));
 264         self->CopyFromDIB(dib);
 265     }
 266     else
 267 #endif // wxUSE_WXDIB
 268     {
 269         // don't copy the bitmap data, but do copy the size, depth, ...
 270         self->m_refData = new wxBitmapRefData(*data);
 271     }
 272
 273     return m_refData;
 274 }
 275
 276 #ifdef __WIN32__
 277
 278 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
 279 {
 280 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 281     // it may be either HICON or HCURSOR
 282     HICON hicon = (HICON)icon.GetHandle();
 283
 284     ICONINFO iconInfo;
 285     if ( !::GetIconInfo(hicon, &iconInfo) )
 286     {
 287         wxLogLastError(wxT("GetIconInfo"));
 288
 289         return false;
 290     }
 291
 292     wxBitmapRefData *refData = new wxBitmapRefData;
 293     m_refData = refData;
 294
 295     int w = icon.GetWidth(),
 296         h = icon.GetHeight();
 297
 298     refData->m_width = w;
 299     refData->m_height = h;
 300     refData->m_depth = wxDisplayDepth();
 301
 302     refData->m_hBitmap = (WXHBITMAP)iconInfo.hbmColor;
 303
 304 #if wxUSE_WXDIB
 305     // If the icon is 32 bits per pixel then it may have alpha channel data,
 306     // although there are some icons that are 32 bpp but have no alpha... So
 307     // convert to a DIB and manually check the 4th byte for each pixel.
 308     BITMAP bm;
 309     if ( ::GetObject(iconInfo.hbmColor, sizeof(BITMAP), (LPVOID)&bm)
 310          && bm.bmBitsPixel == 32)
 311     {
 312         wxDIB dib(iconInfo.hbmColor);
 313         if (dib.IsOk())
 314         {
 315             unsigned char* pixels = dib.GetData();
 316             for (int idx=0; idx<w*h*4; idx+=4)
 317             {
 318                 if (pixels[idx+3] != 0)
 319                 {
 320                     // If there is an alpha byte that is non-zero then set the
 321                     // alpha flag and bail out of the loop.
 322                     refData->m_hasAlpha = true;
 323                     break;
 324                 }
 325             }
 326         }
 327     }
 328 #endif
 329     if ( !refData->m_hasAlpha )
 330     {
 331         // the mask returned by GetIconInfo() is inverted compared to the usual
 332         // wxWin convention
 333         refData->SetMask(wxInvertMask(iconInfo.hbmMask, w, h));
 334     }
 335
 336     // delete the old one now as we don't need it any more
 337     ::DeleteObject(iconInfo.hbmMask);
 338
 339     return true;
 340 #else
 341     wxUnusedVar(icon);
 342     return false;
 343 #endif
 344 }
 345
 346 #endif // Win32
 347
 348 bool wxBitmap::CopyFromCursor(const wxCursor& cursor)
 349 {
 350     UnRef();
 351
 352     if ( !cursor.Ok() )
 353         return false;
 354
 355     return CopyFromIconOrCursor(cursor);
 356 }
 357
 358 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 359 {
 360     UnRef();
 361
 362     if ( !icon.Ok() )
 363         return false;
 364
 365     return CopyFromIconOrCursor(icon);
 366 }
 367
 368 #ifndef NEVER_USE_DIB
 369
 370 bool wxBitmap::CopyFromDIB(const wxDIB& dib)
 371 {
 372     wxCHECK_MSG( dib.IsOk(), false, _T("invalid DIB in CopyFromDIB") );
 373
 374 #ifdef SOMETIMES_USE_DIB
 375     HBITMAP hbitmap = dib.CreateDDB();
 376     if ( !hbitmap )
 377         return false;
 378 #else // ALWAYS_USE_DIB
 379     HBITMAP hbitmap = ((wxDIB &)dib).Detach();  // const_cast
 380 #endif // SOMETIMES_USE_DIB/ALWAYS_USE_DIB
 381
 382     UnRef();
 383
 384     wxBitmapRefData *refData = new wxBitmapRefData;
 385     m_refData = refData;
 386
 387     refData->m_width = dib.GetWidth();
 388     refData->m_height = dib.GetHeight();
 389     refData->m_depth = dib.GetDepth();
 390
 391     refData->m_hBitmap = (WXHBITMAP)hbitmap;
 392
 393 #if wxUSE_PALETTE
 394     wxPalette *palette = dib.CreatePalette();
 395     if ( palette )
 396     {
 397         refData->m_bitmapPalette = *palette;
 398     }
 399
 400     delete palette;
 401 #endif // wxUSE_PALETTE
 402
 403     return true;
 404 }
 405
 406 #endif // NEVER_USE_DIB
 407
 408 wxBitmap::~wxBitmap()
 409 {
 410 }
 411
 412 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 413 {
 414 #ifndef __WXMICROWIN__
 415     wxBitmapRefData *refData = new wxBitmapRefData;
 416     m_refData = refData;
 417
 418     refData->m_width = width;
 419     refData->m_height = height;
 420     refData->m_depth = depth;
 421
 422     char *data;
 423     if ( depth == 1 )
 424     {
 425         // we assume that it is in XBM format which is not quite the same as
 426         // the format CreateBitmap() wants because the order of bytes in the
 427         // line is reversed!
 428         const size_t bytesPerLine = (width + 7) / 8;
 429         const size_t padding = bytesPerLine % 2;
 430         const size_t len = height * ( padding + bytesPerLine );
 431         data = (char *)malloc(len);
 432         const char *src = bits;
 433         char *dst = data;
 434
 435         for ( int rows = 0; rows < height; rows++ )
 436         {
 437             for ( size_t cols = 0; cols < bytesPerLine; cols++ )
 438             {
 439                 unsigned char val = *src++;
 440                 unsigned char reversed = 0;
 441
 442                 for ( int bits = 0; bits < 8; bits++)
 443                 {
 444                     reversed <<= 1;
 445                     reversed |= (unsigned char)(val & 0x01);
 446                     val >>= 1;
 447                 }
 448                 *dst++ = ~reversed;
 449             }
 450
 451             if ( padding )
 452                 *dst++ = 0;
 453         }
 454     }
 455     else
 456     {
 457         // bits should already be in Windows standard format
 458         data = (char *)bits;    // const_cast is harmless
 459     }
 460
 461     HBITMAP hbmp = ::CreateBitmap(width, height, 1, depth, data);
 462     if ( !hbmp )
 463     {
 464         wxLogLastError(wxT("CreateBitmap"));
 465     }
 466
 467     if ( data != bits )
 468     {
 469         free(data);
 470     }
 471
 472     SetHBITMAP((WXHBITMAP)hbmp);
 473 #endif
 474 }
 475
 476 wxBitmap::wxBitmap(int w, int h, int d)
 477 {
 478     (void)Create(w, h, d);
 479 }
 480
 481 wxBitmap::wxBitmap(int w, int h, const wxDC& dc)
 482 {
 483     (void)Create(w, h, dc);
 484 }
 485
 486 wxBitmap::wxBitmap(const void* data, long type, int width, int height, int depth)
 487 {
 488     (void)Create(data, type, width, height, depth);
 489 }
 490
 491 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 492 {
 493     LoadFile(filename, (int)type);
 494 }
 495
 496 bool wxBitmap::Create(int width, int height, int depth)
 497 {
 498     return DoCreate(width, height, depth, 0);
 499 }
 500
 501 bool wxBitmap::Create(int width, int height, const wxDC& dc)
 502 {
 503     wxCHECK_MSG( dc.Ok(), false, _T("invalid HDC in wxBitmap::Create()") );
 504
 505     return DoCreate(width, height, -1, dc.GetHDC());
 506 }
 507
 508 bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)
 509 {
 510     UnRef();
 511
 512     m_refData = new wxBitmapRefData;
 513
 514     GetBitmapData()->m_width = w;
 515     GetBitmapData()->m_height = h;
 516
 517     HBITMAP hbmp    wxDUMMY_INITIALIZE(0);
 518
 519 #ifndef NEVER_USE_DIB
 520     if ( wxShouldCreateDIB(w, h, d, hdc) )
 521     {
 522         if ( d == -1 )
 523         {
 524             // create DIBs without alpha channel by default
 525             d = 24;
 526         }
 527
 528         wxDIB dib(w, h, d);
 529         if ( !dib.IsOk() )
 530            return false;
 531
 532         // don't delete the DIB section in dib object dtor
 533         hbmp = dib.Detach();
 534
 535         GetBitmapData()->m_isDIB = true;
 536         GetBitmapData()->m_depth = d;
 537     }
 538     else // create a DDB
 539 #endif // NEVER_USE_DIB
 540     {
 541 #ifndef ALWAYS_USE_DIB
 542 #ifndef __WXMICROWIN__
 543         if ( d > 0 )
 544         {
 545             hbmp = ::CreateBitmap(w, h, 1, d, NULL);
 546             if ( !hbmp )
 547             {
 548                 wxLogLastError(wxT("CreateBitmap"));
 549             }
 550
 551             GetBitmapData()->m_depth = d;
 552         }
 553         else // d == 0, create bitmap compatible with the screen
 554 #endif // !__WXMICROWIN__
 555         {
 556             ScreenHDC dc;
 557             hbmp = ::CreateCompatibleBitmap(dc, w, h);
 558             if ( !hbmp )
 559             {
 560                 wxLogLastError(wxT("CreateCompatibleBitmap"));
 561             }
 562
 563             GetBitmapData()->m_depth = wxDisplayDepth();
 564         }
 565 #endif // !ALWAYS_USE_DIB
 566     }
 567
 568     SetHBITMAP((WXHBITMAP)hbmp);
 569
 570     return Ok();
 571 }
 572
 573 #if wxUSE_IMAGE
 574
 575 // ----------------------------------------------------------------------------
 576 // wxImage to/from conversions for Microwin
 577 // ----------------------------------------------------------------------------
 578
 579 // Microwin versions are so different from normal ones that it really doesn't
 580 // make sense to use #ifdefs inside the function bodies
 581 #ifdef __WXMICROWIN__
 582
 583 bool wxBitmap::CreateFromImage(const wxImage& image, int depth, const wxDC& dc)
 584 {
 585     // Set this to 1 to experiment with mask code,
 586     // which currently doesn't work
 587     #define USE_MASKS 0
 588
 589     m_refData = new wxBitmapRefData();
 590
 591     // Initial attempt at a simple-minded implementation.
 592     // The bitmap will always be created at the screen depth,
 593     // so the 'depth' argument is ignored.
 594
 595     HDC hScreenDC = ::GetDC(NULL);
 596     int screenDepth = ::GetDeviceCaps(hScreenDC, BITSPIXEL);
 597
 598     HBITMAP hBitmap = ::CreateCompatibleBitmap(hScreenDC, image.GetWidth(), image.GetHeight());
 599     HBITMAP hMaskBitmap = NULL;
 600     HBITMAP hOldMaskBitmap = NULL;
 601     HDC hMaskDC = NULL;
 602     unsigned char maskR = 0;
 603     unsigned char maskG = 0;
 604     unsigned char maskB = 0;
 605
 606     //    printf("Created bitmap %d\n", (int) hBitmap);
 607     if (hBitmap == NULL)
 608     {
 609         ::ReleaseDC(NULL, hScreenDC);
 610         return false;
 611     }
 612     HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
 613
 614     HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
 615     ::ReleaseDC(NULL, hScreenDC);
 616
 617     // created an mono-bitmap for the possible mask
 618     bool hasMask = image.HasMask();
 619
 620     if ( hasMask )
 621     {
 622 #if USE_MASKS
 623         // FIXME: we should be able to pass bpp = 1, but
 624         // GdBlit can't handle a different depth
 625 #if 0
 626         hMaskBitmap = ::CreateBitmap( (WORD)image.GetWidth(), (WORD)image.GetHeight(), 1, 1, NULL );
 627 #else
 628         hMaskBitmap = ::CreateCompatibleBitmap( hMemDC, (WORD)image.GetWidth(), (WORD)image.GetHeight());
 629 #endif
 630         maskR = image.GetMaskRed();
 631         maskG = image.GetMaskGreen();
 632         maskB = image.GetMaskBlue();
 633
 634         if (!hMaskBitmap)
 635         {
 636             hasMask = false;
 637         }
 638         else
 639         {
 640             hScreenDC = ::GetDC(NULL);
 641             hMaskDC = ::CreateCompatibleDC(hScreenDC);
 642            ::ReleaseDC(NULL, hScreenDC);
 643
 644             hOldMaskBitmap = ::SelectObject( hMaskDC, hMaskBitmap);
 645         }
 646 #else
 647         hasMask = false;
 648 #endif
 649     }
 650
 651     int i, j;
 652     for (i = 0; i < image.GetWidth(); i++)
 653     {
 654         for (j = 0; j < image.GetHeight(); j++)
 655         {
 656             unsigned char red = image.GetRed(i, j);
 657             unsigned char green = image.GetGreen(i, j);
 658             unsigned char blue = image.GetBlue(i, j);
 659
 660             ::SetPixel(hMemDC, i, j, PALETTERGB(red, green, blue));
 661
 662             if (hasMask)
 663             {
 664                 // scan the bitmap for the transparent colour and set the corresponding
 665                 // pixels in the mask to BLACK and the rest to WHITE
 666                 if (maskR == red && maskG == green && maskB == blue)
 667                     ::SetPixel(hMaskDC, i, j, PALETTERGB(0, 0, 0));
 668                 else
 669                     ::SetPixel(hMaskDC, i, j, PALETTERGB(255, 255, 255));
 670             }
 671         }
 672     }
 673
 674     ::SelectObject(hMemDC, hOldBitmap);
 675     ::DeleteDC(hMemDC);
 676     if (hasMask)
 677     {
 678         ::SelectObject(hMaskDC, hOldMaskBitmap);
 679         ::DeleteDC(hMaskDC);
 680
 681         ((wxBitmapRefData*)m_refData)->SetMask(hMaskBitmap);
 682     }
 683
 684     SetWidth(image.GetWidth());
 685     SetHeight(image.GetHeight());
 686     SetDepth(screenDepth);
 687     SetHBITMAP( (WXHBITMAP) hBitmap );
 688
 689 #if wxUSE_PALETTE
 690     // Copy the palette from the source image
 691     SetPalette(image.GetPalette());
 692 #endif // wxUSE_PALETTE
 693
 694     return true;
 695 }
 696
 697 wxImage wxBitmap::ConvertToImage() const
 698 {
 699     // Initial attempt at a simple-minded implementation.
 700     // The bitmap will always be created at the screen depth,
 701     // so the 'depth' argument is ignored.
 702     // TODO: transparency (create a mask image)
 703
 704     if (!Ok())
 705     {
 706         wxFAIL_MSG( wxT("bitmap is invalid") );
 707         return wxNullImage;
 708     }
 709
 710     wxImage image;
 711
 712     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 713
 714     // create an wxImage object
 715     int width = GetWidth();
 716     int height = GetHeight();
 717     image.Create( width, height );
 718     unsigned char *data = image.GetData();
 719     if( !data )
 720     {
 721         wxFAIL_MSG( wxT("could not allocate data for image") );
 722         return wxNullImage;
 723     }
 724
 725     HDC hScreenDC = ::GetDC(NULL);
 726
 727     HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
 728     ::ReleaseDC(NULL, hScreenDC);
 729
 730     HBITMAP hBitmap = (HBITMAP) GetHBITMAP();
 731
 732     HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
 733
 734     int i, j;
 735     for (i = 0; i < GetWidth(); i++)
 736     {
 737         for (j = 0; j < GetHeight(); j++)
 738         {
 739             COLORREF color = ::GetPixel(hMemDC, i, j);
 740             unsigned char red = GetRValue(color);
 741             unsigned char green = GetGValue(color);
 742             unsigned char blue = GetBValue(color);
 743
 744             image.SetRGB(i, j, red, green, blue);
 745         }
 746     }
 747
 748     ::SelectObject(hMemDC, hOldBitmap);
 749     ::DeleteDC(hMemDC);
 750
 751 #if wxUSE_PALETTE
 752     // Copy the palette from the source image
 753     if (GetPalette())
 754         image.SetPalette(* GetPalette());
 755 #endif // wxUSE_PALETTE
 756
 757     return image;
 758 }
 759
 760 #endif // __WXMICROWIN__
 761
 762 // ----------------------------------------------------------------------------
 763 // wxImage to/from conversions
 764 // ----------------------------------------------------------------------------
 765
 766 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 767 {
 768     return CreateFromImage(image, depth, 0);
 769 }
 770
 771 bool wxBitmap::CreateFromImage(const wxImage& image, const wxDC& dc)
 772 {
 773     wxCHECK_MSG( dc.Ok(), false,
 774                     _T("invalid HDC in wxBitmap::CreateFromImage()") );
 775
 776     return CreateFromImage(image, -1, dc.GetHDC());
 777 }
 778
 779 #if wxUSE_WXDIB
 780
 781 bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc)
 782 {
 783     wxCHECK_MSG( image.Ok(), false, wxT("invalid image") );
 784
 785     UnRef();
 786
 787     // first convert the image to DIB
 788     const int h = image.GetHeight();
 789     const int w = image.GetWidth();
 790
 791     wxDIB dib(image);
 792     if ( !dib.IsOk() )
 793         return false;
 794
 795     if ( depth == -1 )
 796         depth = dib.GetDepth(); // Get depth from image if none specified
 797
 798     // store the bitmap parameters
 799     wxBitmapRefData *refData = new wxBitmapRefData;
 800     refData->m_width = w;
 801     refData->m_height = h;
 802     refData->m_hasAlpha = image.HasAlpha();
 803
 804     m_refData = refData;
 805
 806
 807     // next either store DIB as is or create a DDB from it
 808     HBITMAP hbitmap     wxDUMMY_INITIALIZE(0);
 809
 810     // are we going to use DIB?
 811     //
 812     // NB: DDBs don't support alpha so if we have alpha channel we must use DIB
 813     if ( image.HasAlpha() || wxShouldCreateDIB(w, h, depth, hdc) )
 814     {
 815         // don't delete the DIB section in dib object dtor
 816         hbitmap = dib.Detach();
 817
 818         refData->m_isDIB = true;
 819         refData->m_depth = depth;
 820     }
 821 #ifndef ALWAYS_USE_DIB
 822     else // we need to convert DIB to DDB
 823     {
 824         hbitmap = dib.CreateDDB((HDC)hdc);
 825
 826         refData->m_depth = depth;
 827     }
 828 #endif // !ALWAYS_USE_DIB
 829
 830     // validate this object
 831     SetHBITMAP((WXHBITMAP)hbitmap);
 832
 833     // finally also set the mask if we have one
 834     if ( image.HasMask() )
 835     {
 836         const size_t len  = 2*((w+15)/16);
 837         BYTE *src  = image.GetData();
 838         BYTE *data = new BYTE[h*len];
 839         memset(data, 0, h*len);
 840         BYTE r = image.GetMaskRed(),
 841              g = image.GetMaskGreen(),
 842              b = image.GetMaskBlue();
 843         BYTE *dst = data;
 844         for ( int y = 0; y < h; y++, dst += len )
 845         {
 846             BYTE *dstLine = dst;
 847             BYTE mask = 0x80;
 848             for ( int x = 0; x < w; x++, src += 3 )
 849             {
 850                 if (src[0] != r || src[1] != g || src[2] != b)
 851                     *dstLine |= mask;
 852
 853                 if ( (mask >>= 1) == 0 )
 854                 {
 855                     dstLine++;
 856                     mask = 0x80;
 857                 }
 858             }
 859         }
 860
 861         hbitmap = ::CreateBitmap(w, h, 1, 1, data);
 862         if ( !hbitmap )
 863         {
 864             wxLogLastError(_T("CreateBitmap(mask)"));
 865         }
 866         else
 867         {
 868             SetMask(new wxMask((WXHBITMAP)hbitmap));
 869         }
 870
 871         delete[] data;
 872     }
 873
 874     return true;
 875 }
 876
 877 wxImage wxBitmap::ConvertToImage() const
 878 {
 879     // convert DDB to DIB
 880     wxDIB dib(*this);
 881
 882     if ( !dib.IsOk() )
 883     {
 884         return wxNullImage;
 885     }
 886
 887     // and then DIB to our wxImage
 888     wxImage image = dib.ConvertToImage();
 889     if ( !image.Ok() )
 890     {
 891         return wxNullImage;
 892     }
 893
 894     // now do the same for the mask, if we have any
 895     HBITMAP hbmpMask = GetMask() ? (HBITMAP) GetMask()->GetMaskBitmap() : NULL;
 896     if ( hbmpMask )
 897     {
 898         wxDIB dibMask(hbmpMask);
 899         if ( dibMask.IsOk() )
 900         {
 901             // TODO: use wxRawBitmap to iterate over DIB
 902
 903             // we hard code the mask colour for now but we could also make an
 904             // effort (and waste time) to choose a colour not present in the
 905             // image already to avoid having to fudge the pixels below --
 906             // whether it's worth to do it is unclear however
 907             static const int MASK_RED = 1;
 908             static const int MASK_GREEN = 2;
 909             static const int MASK_BLUE = 3;
 910             static const int MASK_BLUE_REPLACEMENT = 2;
 911
 912             const int h = dibMask.GetHeight();
 913             const int w = dibMask.GetWidth();
 914             const int bpp = dibMask.GetDepth();
 915             const int maskBytesPerPixel = bpp >> 3;
 916             const int maskBytesPerLine = wxDIB::GetLineSize(w, bpp);
 917             unsigned char *data = image.GetData();
 918
 919             // remember that DIBs are stored in bottom to top order
 920             unsigned char *
 921                 maskLineStart = dibMask.GetData() + ((h - 1) * maskBytesPerLine);
 922
 923             for ( int y = 0; y < h; y++, maskLineStart -= maskBytesPerLine )
 924             {
 925                 // traverse one mask DIB line
 926                 unsigned char *mask = maskLineStart;
 927                 for ( int x = 0; x < w; x++, mask += maskBytesPerPixel )
 928                 {
 929                     // should this pixel be transparent?
 930                     if ( *mask )
 931                     {
 932                         // no, check that it isn't transparent by accident
 933                         if ( (data[0] == MASK_RED) &&
 934                                 (data[1] == MASK_GREEN) &&
 935                                     (data[2] == MASK_BLUE) )
 936                         {
 937                             // we have to fudge the colour a bit to prevent
 938                             // this pixel from appearing transparent
 939                             data[2] = MASK_BLUE_REPLACEMENT;
 940                         }
 941
 942                         data += 3;
 943                     }
 944                     else // yes, transparent pixel
 945                     {
 946                         *data++ = MASK_RED;
 947                         *data++ = MASK_GREEN;
 948                         *data++ = MASK_BLUE;
 949                     }
 950                 }
 951             }
 952
 953             image.SetMaskColour(MASK_RED, MASK_GREEN, MASK_BLUE);
 954         }
 955     }
 956
 957     return image;
 958 }
 959
 960 #else // !wxUSE_WXDIB
 961
 962 bool
 963 wxBitmap::CreateFromImage(const wxImage& WXUNUSED(image),
 964                           int WXUNUSED(depth),
 965                           WXHDC WXUNUSED(hdc))
 966 {
 967     return false;
 968 }
 969
 970 wxImage wxBitmap::ConvertToImage() const
 971 {
 972     return wxImage();
 973 }
 974
 975 #endif // wxUSE_WXDIB/!wxUSE_WXDIB
 976
 977 #endif // wxUSE_IMAGE
 978
 979 // ----------------------------------------------------------------------------
 980 // loading and saving bitmaps
 981 // ----------------------------------------------------------------------------
 982
 983 bool wxBitmap::LoadFile(const wxString& filename, long type)
 984 {
 985     UnRef();
 986
 987     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 988
 989     if ( handler )
 990     {
 991         m_refData = new wxBitmapRefData;
 992
 993         return handler->LoadFile(this, filename, type, -1, -1);
 994     }
 995 #if wxUSE_IMAGE && wxUSE_WXDIB
 996     else // no bitmap handler found
 997     {
 998         wxImage image;
 999         if ( image.LoadFile( filename, type ) && image.Ok() )
1000         {
1001             *this = wxBitmap(image);
1002
1003             return true;
1004         }
1005     }
1006 #endif // wxUSE_IMAGE
1007
1008     return false;
1009 }
1010
1011 bool wxBitmap::Create(const void* data, long type, int width, int height, int depth)
1012 {
1013     UnRef();
1014
1015     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
1016
1017     if ( !handler )
1018     {
1019         wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), type);
1020
1021         return false;
1022     }
1023
1024     m_refData = new wxBitmapRefData;
1025
1026     return handler->Create(this, data, type, width, height, depth);
1027 }
1028
1029 bool wxBitmap::SaveFile(const wxString& filename,
1030                         int type,
1031                         const wxPalette *palette)
1032 {
1033     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
1034
1035     if ( handler )
1036     {
1037         return handler->SaveFile(this, filename, type, palette);
1038     }
1039 #if wxUSE_IMAGE && wxUSE_WXDIB
1040     else // no bitmap handler found
1041     {
1042         // FIXME what about palette? shouldn't we use it?
1043         wxImage image = ConvertToImage();
1044         if ( image.Ok() )
1045         {
1046             return image.SaveFile(filename, type);
1047         }
1048     }
1049 #endif // wxUSE_IMAGE
1050
1051     return false;
1052 }
1053
1054 // ----------------------------------------------------------------------------
1055 // sub bitmap extraction
1056 // ----------------------------------------------------------------------------
1057
1058 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
1059 {
1060     wxCHECK_MSG( Ok() &&
1061                  (rect.x >= 0) && (rect.y >= 0) &&
1062                  (rect.x+rect.width <= GetWidth()) &&
1063                  (rect.y+rect.height <= GetHeight()),
1064                  wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
1065
1066     wxBitmap ret( rect.width, rect.height, GetDepth() );
1067     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
1068
1069 #ifndef __WXMICROWIN__
1070     // handle alpha channel, if any
1071     if (HasAlpha())
1072         ret.UseAlpha();
1073
1074     // copy bitmap data
1075     MemoryHDC dcSrc,
1076               dcDst;
1077
1078     {
1079         SelectInHDC selectSrc(dcSrc, GetHbitmap()),
1080                     selectDst(dcDst, GetHbitmapOf(ret));
1081
1082         if ( !selectSrc || !selectDst )
1083         {
1084             wxLogLastError(_T("SelectObjct(hBitmap)"));
1085         }
1086
1087         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
1088                        dcSrc, rect.x, rect.y, SRCCOPY) )
1089         {
1090             wxLogLastError(_T("BitBlt"));
1091         }
1092     }
1093
1094     // copy mask if there is one
1095     if ( GetMask() )
1096     {
1097         HBITMAP hbmpMask = ::CreateBitmap(rect.width, rect.height, 1, 1, 0);
1098
1099         SelectInHDC selectSrc(dcSrc, (HBITMAP) GetMask()->GetMaskBitmap()),
1100                     selectDst(dcDst, hbmpMask);
1101
1102         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
1103                        dcSrc, rect.x, rect.y, SRCCOPY) )
1104         {
1105             wxLogLastError(_T("BitBlt"));
1106         }
1107
1108         wxMask *mask = new wxMask((WXHBITMAP) hbmpMask);
1109         ret.SetMask(mask);
1110     }
1111 #endif // !__WXMICROWIN__
1112
1113     return ret;
1114 }
1115
1116 // ----------------------------------------------------------------------------
1117 // wxBitmap accessors
1118 // ----------------------------------------------------------------------------
1119
1120 #if wxUSE_PALETTE
1121 wxPalette* wxBitmap::GetPalette() const
1122 {
1123     return GetBitmapData() ? &GetBitmapData()->m_bitmapPalette
1124                            : (wxPalette *) NULL;
1125 }
1126 #endif
1127
1128 wxMask *wxBitmap::GetMask() const
1129 {
1130     return GetBitmapData() ? GetBitmapData()->GetMask() : (wxMask *) NULL;
1131 }
1132
1133 wxBitmap wxBitmap::GetMaskBitmap() const
1134 {
1135     wxBitmap bmp;
1136     wxMask *mask = GetMask();
1137     if ( mask )
1138         bmp.SetHBITMAP(mask->GetMaskBitmap());
1139     return bmp;
1140 }
1141
1142 #ifdef __WXDEBUG__
1143
1144 wxDC *wxBitmap::GetSelectedInto() const
1145 {
1146     return GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC *) NULL;
1147 }
1148
1149 #endif
1150
1151 #if WXWIN_COMPATIBILITY_2_4
1152
1153 int wxBitmap::GetQuality() const
1154 {
1155     return 0;
1156 }
1157
1158 #endif // WXWIN_COMPATIBILITY_2_4
1159
1160 void wxBitmap::UseAlpha()
1161 {
1162     if ( GetBitmapData() )
1163         GetBitmapData()->m_hasAlpha = true;
1164 }
1165
1166 bool wxBitmap::HasAlpha() const
1167 {
1168     return GetBitmapData() && GetBitmapData()->m_hasAlpha;
1169 }
1170
1171 // ----------------------------------------------------------------------------
1172 // wxBitmap setters
1173 // ----------------------------------------------------------------------------
1174
1175 #ifdef __WXDEBUG__
1176
1177 void wxBitmap::SetSelectedInto(wxDC *dc)
1178 {
1179     if ( GetBitmapData() )
1180         GetBitmapData()->m_selectedInto = dc;
1181 }
1182
1183 #endif
1184
1185 #if wxUSE_PALETTE
1186
1187 void wxBitmap::SetPalette(const wxPalette& palette)
1188 {
1189     AllocExclusive();
1190
1191     GetBitmapData()->m_bitmapPalette = palette;
1192 }
1193
1194 #endif // wxUSE_PALETTE
1195
1196 void wxBitmap::SetMask(wxMask *mask)
1197 {
1198     AllocExclusive();
1199
1200     GetBitmapData()->SetMask(mask);
1201 }
1202
1203 #if WXWIN_COMPATIBILITY_2_4
1204
1205 void wxBitmap::SetQuality(int WXUNUSED(quality))
1206 {
1207 }
1208
1209 #endif // WXWIN_COMPATIBILITY_2_4
1210
1211 // ----------------------------------------------------------------------------
1212 // raw bitmap access support
1213 // ----------------------------------------------------------------------------
1214
1215 #ifdef wxHAVE_RAW_BITMAP
1216 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
1217 {
1218 #if wxUSE_WXDIB
1219     if ( !Ok() )
1220     {
1221         // no bitmap, no data (raw or otherwise)
1222         return NULL;
1223     }
1224
1225     // if we're already a DIB we can access our data directly, but if not we
1226     // need to convert this DDB to a DIB section and use it for raw access and
1227     // then convert it back
1228     HBITMAP hDIB;
1229     if ( !GetBitmapData()->m_isDIB )
1230     {
1231         wxCHECK_MSG( !GetBitmapData()->m_dib, NULL,
1232                         _T("GetRawData() may be called only once") );
1233
1234         wxDIB *dib = new wxDIB(*this);
1235         if ( !dib->IsOk() )
1236         {
1237             delete dib;
1238
1239             return NULL;
1240         }
1241
1242         // we'll free it in UngetRawData()
1243         GetBitmapData()->m_dib = dib;
1244
1245         hDIB = dib->GetHandle();
1246     }
1247     else // we're a DIB
1248     {
1249         hDIB = GetHbitmap();
1250     }
1251
1252     DIBSECTION ds;
1253     if ( ::GetObject(hDIB, sizeof(ds), &ds) != sizeof(DIBSECTION) )
1254     {
1255         wxFAIL_MSG( _T("failed to get DIBSECTION from a DIB?") );
1256
1257         return NULL;
1258     }
1259
1260     // check that the bitmap is in correct format
1261     if ( ds.dsBm.bmBitsPixel != bpp )
1262     {
1263         wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") );
1264
1265         return NULL;
1266     }
1267
1268     // ok, store the relevant info in wxPixelDataBase
1269     const LONG h = ds.dsBm.bmHeight;
1270
1271     data.m_width = ds.dsBm.bmWidth;
1272     data.m_height = h;
1273
1274     // remember that DIBs are stored in top to bottom order!
1275     // (We can't just use ds.dsBm.bmWidthBytes here, because it isn't always a
1276     // multiple of 2, as required by the documentation.  So we use the official
1277     // formula, which we already use elsewhere.)
1278     const LONG bytesPerRow =
1279         wxDIB::GetLineSize(ds.dsBm.bmWidth, ds.dsBm.bmBitsPixel);
1280     data.m_stride = -bytesPerRow;
1281
1282     char *bits = (char *)ds.dsBm.bmBits;
1283     if ( h > 1 )
1284     {
1285         bits += (h - 1)*bytesPerRow;
1286     }
1287
1288     return bits;
1289 #else
1290     return NULL;
1291 #endif
1292 }
1293
1294 void wxBitmap::UngetRawData(wxPixelDataBase& dataBase)
1295 {
1296 #if wxUSE_WXDIB
1297     if ( !Ok() )
1298         return;
1299
1300     if ( !&dataBase )
1301     {
1302         // invalid data, don't crash -- but don't assert neither as we're
1303         // called automatically from wxPixelDataBase dtor and so there is no
1304         // way to prevent this from happening
1305         return;
1306     }
1307
1308     // if we're a DDB we need to convert DIB back to DDB now to make the
1309     // changes made via raw bitmap access effective
1310     if ( !GetBitmapData()->m_isDIB )
1311     {
1312         wxDIB *dib = GetBitmapData()->m_dib;
1313         GetBitmapData()->m_dib = NULL;
1314
1315         // TODO: convert
1316
1317         delete dib;
1318     }
1319 #endif // wxUSE_WXDIB
1320 }
1321 #endif // #ifdef wxHAVE_RAW_BITMAP
1322
1323 // ----------------------------------------------------------------------------
1324 // wxMask
1325 // ----------------------------------------------------------------------------
1326
1327 wxMask::wxMask()
1328 {
1329     m_maskBitmap = 0;
1330 }
1331
1332 // Construct a mask from a bitmap and a colour indicating
1333 // the transparent area
1334 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
1335 {
1336     m_maskBitmap = 0;
1337     Create(bitmap, colour);
1338 }
1339
1340 // Construct a mask from a bitmap and a palette index indicating
1341 // the transparent area
1342 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
1343 {
1344     m_maskBitmap = 0;
1345     Create(bitmap, paletteIndex);
1346 }
1347
1348 // Construct a mask from a mono bitmap (copies the bitmap).
1349 wxMask::wxMask(const wxBitmap& bitmap)
1350 {
1351     m_maskBitmap = 0;
1352     Create(bitmap);
1353 }
1354
1355 wxMask::~wxMask()
1356 {
1357     if ( m_maskBitmap )
1358         ::DeleteObject((HBITMAP) m_maskBitmap);
1359 }
1360
1361 // Create a mask from a mono bitmap (copies the bitmap).
1362 bool wxMask::Create(const wxBitmap& bitmap)
1363 {
1364 #ifndef __WXMICROWIN__
1365     wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, false,
1366                  _T("can't create mask from invalid or not monochrome bitmap") );
1367
1368     if ( m_maskBitmap )
1369     {
1370         ::DeleteObject((HBITMAP) m_maskBitmap);
1371         m_maskBitmap = 0;
1372     }
1373
1374     m_maskBitmap = (WXHBITMAP) CreateBitmap(
1375                                             bitmap.GetWidth(),
1376                                             bitmap.GetHeight(),
1377                                             1, 1, 0
1378                                            );
1379     HDC srcDC = CreateCompatibleDC(0);
1380     SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
1381     HDC destDC = CreateCompatibleDC(0);
1382     SelectObject(destDC, (HBITMAP) m_maskBitmap);
1383     BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
1384     SelectObject(srcDC, 0);
1385     DeleteDC(srcDC);
1386     SelectObject(destDC, 0);
1387     DeleteDC(destDC);
1388     return true;
1389 #else
1390     wxUnusedVar(bitmap);
1391     return false;
1392 #endif
1393 }
1394
1395 // Create a mask from a bitmap and a palette index indicating
1396 // the transparent area
1397 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
1398 {
1399     if ( m_maskBitmap )
1400     {
1401         ::DeleteObject((HBITMAP) m_maskBitmap);
1402         m_maskBitmap = 0;
1403     }
1404
1405 #if wxUSE_PALETTE
1406     if (bitmap.Ok() && bitmap.GetPalette()->Ok())
1407     {
1408         unsigned char red, green, blue;
1409         if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
1410         {
1411             wxColour transparentColour(red, green, blue);
1412             return Create(bitmap, transparentColour);
1413         }
1414     }
1415 #endif // wxUSE_PALETTE
1416
1417     return false;
1418 }
1419
1420 // Create a mask from a bitmap and a colour indicating
1421 // the transparent area
1422 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
1423 {
1424 #ifndef __WXMICROWIN__
1425     wxCHECK_MSG( bitmap.Ok(), false, _T("invalid bitmap in wxMask::Create") );
1426
1427     if ( m_maskBitmap )
1428     {
1429         ::DeleteObject((HBITMAP) m_maskBitmap);
1430         m_maskBitmap = 0;
1431     }
1432
1433     int width = bitmap.GetWidth(),
1434         height = bitmap.GetHeight();
1435
1436     // scan the bitmap for the transparent colour and set the corresponding
1437     // pixels in the mask to BLACK and the rest to WHITE
1438     COLORREF maskColour = wxColourToPalRGB(colour);
1439     m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0);
1440
1441     HDC srcDC = ::CreateCompatibleDC(NULL);
1442     HDC destDC = ::CreateCompatibleDC(NULL);
1443     if ( !srcDC || !destDC )
1444     {
1445         wxLogLastError(wxT("CreateCompatibleDC"));
1446     }
1447
1448     bool ok = true;
1449
1450     // SelectObject() will fail
1451     wxASSERT_MSG( !bitmap.GetSelectedInto(),
1452                   _T("bitmap can't be selected in another DC") );
1453
1454     HGDIOBJ hbmpSrcOld = ::SelectObject(srcDC, GetHbitmapOf(bitmap));
1455     if ( !hbmpSrcOld )
1456     {
1457         wxLogLastError(wxT("SelectObject"));
1458
1459         ok = false;
1460     }
1461
1462     HGDIOBJ hbmpDstOld = ::SelectObject(destDC, (HBITMAP)m_maskBitmap);
1463     if ( !hbmpDstOld )
1464     {
1465         wxLogLastError(wxT("SelectObject"));
1466
1467         ok = false;
1468     }
1469
1470     if ( ok )
1471     {
1472         // this will create a monochrome bitmap with 0 points for the pixels
1473         // which have the same value as the background colour and 1 for the
1474         // others
1475         ::SetBkColor(srcDC, maskColour);
1476         ::BitBlt(destDC, 0, 0, width, height, srcDC, 0, 0, NOTSRCCOPY);
1477     }
1478
1479     ::SelectObject(srcDC, hbmpSrcOld);
1480     ::DeleteDC(srcDC);
1481     ::SelectObject(destDC, hbmpDstOld);
1482     ::DeleteDC(destDC);
1483
1484     return ok;
1485 #else // __WXMICROWIN__
1486     wxUnusedVar(bitmap);
1487     wxUnusedVar(colour);
1488     return false;
1489 #endif // __WXMICROWIN__/!__WXMICROWIN__
1490 }
1491
1492 // ----------------------------------------------------------------------------
1493 // wxBitmapHandler
1494 // ----------------------------------------------------------------------------
1495
1496 bool wxBitmapHandler::Create(wxGDIImage *image,
1497                              const void* data,
1498                              long flags,
1499                              int width, int height, int depth)
1500 {
1501     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1502
1503     return bitmap && Create(bitmap, data, flags, width, height, depth);
1504 }
1505
1506 bool wxBitmapHandler::Load(wxGDIImage *image,
1507                            const wxString& name,
1508                            long flags,
1509                            int width, int height)
1510 {
1511     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1512
1513     return bitmap && LoadFile(bitmap, name, flags, width, height);
1514 }
1515
1516 bool wxBitmapHandler::Save(wxGDIImage *image,
1517                            const wxString& name,
1518                            int type)
1519 {
1520     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1521
1522     return bitmap && SaveFile(bitmap, name, type);
1523 }
1524
1525 // ----------------------------------------------------------------------------
1526 // DIB functions
1527 // ----------------------------------------------------------------------------
1528
1529 #ifndef __WXMICROWIN__
1530 bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
1531                  HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
1532 {
1533    unsigned long   i, headerSize;
1534
1535    // Allocate space for a DIB header
1536    headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
1537    LPBITMAPINFO lpDIBheader = (BITMAPINFO *) malloc(headerSize);
1538    LPPALETTEENTRY lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
1539
1540    GetPaletteEntries(hPal, 0, 256, lpPe);
1541
1542    memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
1543
1544    // Fill in the static parts of the DIB header
1545    lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1546    lpDIBheader->bmiHeader.biWidth = xSize;
1547    lpDIBheader->bmiHeader.biHeight = ySize;
1548    lpDIBheader->bmiHeader.biPlanes = 1;
1549
1550    // this value must be 1, 4, 8 or 24 so PixelDepth can only be
1551    lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
1552    lpDIBheader->bmiHeader.biCompression = BI_RGB;
1553    lpDIBheader->bmiHeader.biSizeImage = (xSize * abs(ySize) * bitsPerPixel) >> 3;
1554    lpDIBheader->bmiHeader.biClrUsed = 256;
1555
1556
1557    // Initialize the DIB palette
1558    for (i = 0; i < 256; i++) {
1559       lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
1560       lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
1561       lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
1562       lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
1563    }
1564
1565    *lpDIBHeader = lpDIBheader;
1566
1567    return true;
1568 }
1569
1570 void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
1571 {
1572     free(lpDIBHeader);
1573 }
1574 #endif
1575
1576 // ----------------------------------------------------------------------------
1577 // global helper functions implemented here
1578 // ----------------------------------------------------------------------------
1579
1580 // helper of wxBitmapToHICON/HCURSOR
1581 static
1582 HICON wxBitmapToIconOrCursor(const wxBitmap& bmp,
1583                              bool iconWanted,
1584                              int hotSpotX,
1585                              int hotSpotY)
1586 {
1587     if ( !bmp.Ok() )
1588     {
1589         // we can't create an icon/cursor form nothing
1590         return 0;
1591     }
1592
1593     if ( bmp.HasAlpha() )
1594     {
1595         // Create an empty mask bitmap.
1596         // it doesn't seem to work if we mess with the mask at all.
1597         HBITMAP hMonoBitmap = CreateBitmap(bmp.GetWidth(),bmp.GetHeight(),1,1,NULL);
1598
1599         ICONINFO iconInfo;
1600         wxZeroMemory(iconInfo);
1601         iconInfo.fIcon = iconWanted;  // do we want an icon or a cursor?
1602         if ( !iconWanted )
1603         {
1604             iconInfo.xHotspot = hotSpotX;
1605             iconInfo.yHotspot = hotSpotY;
1606         }
1607
1608         iconInfo.hbmMask = hMonoBitmap;
1609         iconInfo.hbmColor = GetHbitmapOf(bmp);
1610
1611         HICON hicon = ::CreateIconIndirect(&iconInfo);
1612
1613         ::DeleteObject(hMonoBitmap);
1614
1615         return hicon;
1616     }
1617
1618     wxMask* mask = bmp.GetMask();
1619
1620     if ( !mask )
1621     {
1622         // we must have a mask for an icon, so even if it's probably incorrect,
1623         // do create it (grey is the "standard" transparent colour)
1624         mask = new wxMask(bmp, *wxLIGHT_GREY);
1625     }
1626
1627     ICONINFO iconInfo;
1628     wxZeroMemory(iconInfo);
1629     iconInfo.fIcon = iconWanted;  // do we want an icon or a cursor?
1630     if ( !iconWanted )
1631     {
1632         iconInfo.xHotspot = hotSpotX;
1633         iconInfo.yHotspot = hotSpotY;
1634     }
1635
1636     iconInfo.hbmMask = wxInvertMask((HBITMAP)mask->GetMaskBitmap());
1637     iconInfo.hbmColor = GetHbitmapOf(bmp);
1638
1639     // black out the transparent area to preserve background colour, because
1640     // Windows blits the original bitmap using SRCINVERT (XOR) after applying
1641     // the mask to the dest rect.
1642     {
1643         MemoryHDC dcSrc, dcDst;
1644         SelectInHDC selectMask(dcSrc, (HBITMAP)mask->GetMaskBitmap()),
1645                     selectBitmap(dcDst, iconInfo.hbmColor);
1646
1647         if ( !::BitBlt(dcDst, 0, 0, bmp.GetWidth(), bmp.GetHeight(),
1648                        dcSrc, 0, 0, SRCAND) )
1649         {
1650             wxLogLastError(_T("BitBlt"));
1651         }
1652     }
1653
1654     HICON hicon = ::CreateIconIndirect(&iconInfo);
1655
1656     if ( !bmp.GetMask() && !bmp.HasAlpha() )
1657     {
1658         // we created the mask, now delete it
1659         delete mask;
1660     }
1661
1662     // delete the inverted mask bitmap we created as well
1663     ::DeleteObject(iconInfo.hbmMask);
1664
1665     return hicon;
1666 }
1667
1668 HICON wxBitmapToHICON(const wxBitmap& bmp)
1669 {
1670     return wxBitmapToIconOrCursor(bmp, true, 0, 0);
1671 }
1672
1673 HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY)
1674 {
1675     return (HCURSOR)wxBitmapToIconOrCursor(bmp, false, hotSpotX, hotSpotY);
1676 }
1677
1678 HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h)
1679 {
1680 #ifndef __WXMICROWIN__
1681     wxCHECK_MSG( hbmpMask, 0, _T("invalid bitmap in wxInvertMask") );
1682
1683     // get width/height from the bitmap if not given
1684     if ( !w || !h )
1685     {
1686         BITMAP bm;
1687         ::GetObject(hbmpMask, sizeof(BITMAP), (LPVOID)&bm);
1688         w = bm.bmWidth;
1689         h = bm.bmHeight;
1690     }
1691
1692     HDC hdcSrc = ::CreateCompatibleDC(NULL);
1693     HDC hdcDst = ::CreateCompatibleDC(NULL);
1694     if ( !hdcSrc || !hdcDst )
1695     {
1696         wxLogLastError(wxT("CreateCompatibleDC"));
1697     }
1698
1699     HBITMAP hbmpInvMask = ::CreateBitmap(w, h, 1, 1, 0);
1700     if ( !hbmpInvMask )
1701     {
1702         wxLogLastError(wxT("CreateBitmap"));
1703     }
1704
1705     HGDIOBJ srcTmp = ::SelectObject(hdcSrc, hbmpMask);
1706     HGDIOBJ dstTmp = ::SelectObject(hdcDst, hbmpInvMask);
1707     if ( !::BitBlt(hdcDst, 0, 0, w, h,
1708                    hdcSrc, 0, 0,
1709                    NOTSRCCOPY) )
1710     {
1711         wxLogLastError(wxT("BitBlt"));
1712     }
1713
1714     // Deselect objects
1715     SelectObject(hdcSrc,srcTmp);
1716     SelectObject(hdcDst,dstTmp);
1717
1718     ::DeleteDC(hdcSrc);
1719     ::DeleteDC(hdcDst);
1720
1721     return hbmpInvMask;
1722 #else
1723     return 0;
1724 #endif
1725 }