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 #if !defined(__WXMICROWIN__)
  47 #include "wx/msw/dib.h"
  48 #endif
  49
  50 #include "wx/image.h"
  51 #include "wx/xpmdecod.h"
  52
  53 // missing from mingw32 header
  54 #ifndef CLR_INVALID
  55     #define CLR_INVALID ((COLORREF)-1)
  56 #endif // no CLR_INVALID
  57
  58 // ----------------------------------------------------------------------------
  59 // Bitmap data
  60 // ----------------------------------------------------------------------------
  61
  62 class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData
  63 {
  64 public:
  65     wxBitmapRefData();
  66     virtual ~wxBitmapRefData() { Free(); }
  67
  68     virtual void Free();
  69
  70     // set the mask object to use as the mask, we take ownership of it
  71     void SetMask(wxMask *mask)
  72     {
  73         delete m_bitmapMask;
  74         m_bitmapMask = mask;
  75     }
  76
  77     // set the HBITMAP to use as the mask
  78     void SetMask(HBITMAP hbmpMask)
  79     {
  80         SetMask(new wxMask((WXHBITMAP)hbmpMask));
  81     }
  82
  83     // return the mask
  84     wxMask *GetMask() const { return m_bitmapMask; }
  85
  86 public:
  87 #if wxUSE_PALETTE
  88     wxPalette     m_bitmapPalette;
  89 #endif // wxUSE_PALETTE
  90
  91     // MSW-specific
  92     // ------------
  93
  94 #ifdef __WXDEBUG__
  95     // this field is solely for error checking: we detect selecting a bitmap
  96     // into more than one DC at once or deleting a bitmap still selected into a
  97     // DC (both are serious programming errors under Windows)
  98     wxDC         *m_selectedInto;
  99 #endif // __WXDEBUG__
 100
 101     // true if we have alpha transparency info and can be drawn using
 102     // AlphaBlend()
 103     bool m_hasAlpha;
 104
 105 private:
 106     // optional mask for transparent drawing
 107     wxMask       *m_bitmapMask;
 108
 109     DECLARE_NO_COPY_CLASS(wxBitmapRefData)
 110 };
 111
 112 // ----------------------------------------------------------------------------
 113 // macros
 114 // ----------------------------------------------------------------------------
 115
 116 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 117 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 118
 119 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 120
 121 // ============================================================================
 122 // implementation
 123 // ============================================================================
 124
 125 // ----------------------------------------------------------------------------
 126 // wxBitmapRefData
 127 // ----------------------------------------------------------------------------
 128
 129 wxBitmapRefData::wxBitmapRefData()
 130 {
 131 #ifdef __WXDEBUG__
 132     m_selectedInto = NULL;
 133 #endif
 134     m_bitmapMask = NULL;
 135     m_hBitmap = (WXHBITMAP) NULL;
 136     m_hasAlpha = FALSE;
 137 }
 138
 139 void wxBitmapRefData::Free()
 140 {
 141     wxASSERT_MSG( !m_selectedInto,
 142                   wxT("deleting bitmap still selected into wxMemoryDC") );
 143
 144     if ( m_hBitmap)
 145     {
 146         if ( !::DeleteObject((HBITMAP)m_hBitmap) )
 147         {
 148             wxLogLastError(wxT("DeleteObject(hbitmap)"));
 149         }
 150     }
 151
 152     delete m_bitmapMask;
 153     m_bitmapMask = NULL;
 154 }
 155
 156 // ----------------------------------------------------------------------------
 157 // wxBitmap creation
 158 // ----------------------------------------------------------------------------
 159
 160 // this function should be called from all wxBitmap ctors
 161 void wxBitmap::Init()
 162 {
 163     // m_refData = NULL; done in the base class ctor
 164
 165 }
 166
 167 wxGDIImageRefData *wxBitmap::CreateData() const
 168 {
 169     return new wxBitmapRefData;
 170 }
 171
 172 #ifdef __WIN32__
 173
 174 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
 175 {
 176 #ifndef __WXMICROWIN__
 177     // it may be either HICON or HCURSOR
 178     HICON hicon = (HICON)icon.GetHandle();
 179
 180     ICONINFO iconInfo;
 181     if ( !::GetIconInfo(hicon, &iconInfo) )
 182     {
 183         wxLogLastError(wxT("GetIconInfo"));
 184
 185         return FALSE;
 186     }
 187
 188     wxBitmapRefData *refData = new wxBitmapRefData;
 189     m_refData = refData;
 190
 191     int w = icon.GetWidth(),
 192         h = icon.GetHeight();
 193
 194     refData->m_width = w;
 195     refData->m_height = h;
 196     refData->m_depth = wxDisplayDepth();
 197
 198     refData->m_hBitmap = (WXHBITMAP)iconInfo.hbmColor;
 199
 200     // the mask returned by GetIconInfo() is inversed compared to the usual
 201     // wxWin convention
 202     refData->SetMask(wxInvertMask(iconInfo.hbmMask, w, h));
 203
 204
 205     // delete the old one now as we don't need it any more
 206     ::DeleteObject(iconInfo.hbmMask);
 207
 208 #if WXWIN_COMPATIBILITY_2
 209     refData->m_ok = TRUE;
 210 #endif // WXWIN_COMPATIBILITY_2
 211
 212     return TRUE;
 213 #else
 214     return FALSE;
 215 #endif
 216 }
 217
 218 #endif // Win32
 219
 220 bool wxBitmap::CopyFromCursor(const wxCursor& cursor)
 221 {
 222     UnRef();
 223
 224     if ( !cursor.Ok() )
 225         return FALSE;
 226
 227 #ifdef __WIN16__
 228     wxFAIL_MSG( _T("don't know how to convert cursor to bitmap") );
 229
 230     return FALSE;
 231 #else
 232     return CopyFromIconOrCursor(cursor);
 233 #endif // Win16
 234 }
 235
 236 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 237 {
 238     UnRef();
 239
 240     if ( !icon.Ok() )
 241         return FALSE;
 242
 243     // GetIconInfo() doesn't exist under Win16 and I don't know any other way
 244     // to create a bitmap from icon there - but using this way we won't have
 245     // the mask (FIXME)
 246 #ifdef __WIN16__
 247     int width = icon.GetWidth(),
 248         height = icon.GetHeight();
 249
 250     // copy the icon to the bitmap
 251     ScreenHDC hdcScreen;
 252     HDC hdc = ::CreateCompatibleDC(hdcScreen);
 253     HBITMAP hbitmap = ::CreateCompatibleBitmap(hdcScreen, width, height);
 254     HBITMAP hbmpOld = (HBITMAP)::SelectObject(hdc, hbitmap);
 255
 256     ::DrawIcon(hdc, 0, 0, GetHiconOf(icon));
 257
 258     ::SelectObject(hdc, hbmpOld);
 259     ::DeleteDC(hdc);
 260
 261     wxBitmapRefData *refData = new wxBitmapRefData;
 262     m_refData = refData;
 263
 264     refData->m_width = width;
 265     refData->m_height = height;
 266     refData->m_depth = wxDisplayDepth();
 267
 268     refData->m_hBitmap = (WXHBITMAP)hbitmap;
 269
 270 #if WXWIN_COMPATIBILITY_2
 271     refData->m_ok = TRUE;
 272 #endif // WXWIN_COMPATIBILITY_2
 273
 274     return TRUE;
 275 #else // Win32
 276     return CopyFromIconOrCursor(icon);
 277 #endif // Win16/Win32
 278 }
 279
 280 wxBitmap::~wxBitmap()
 281 {
 282 }
 283
 284 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 285 {
 286     Init();
 287
 288 #ifndef __WXMICROWIN__
 289     wxBitmapRefData *refData = new wxBitmapRefData;
 290     m_refData = refData;
 291
 292     refData->m_width = width;
 293     refData->m_height = height;
 294     refData->m_depth = depth;
 295
 296     char *data;
 297     if ( depth == 1 )
 298     {
 299         // we assume that it is in XBM format which is not quite the same as
 300         // the format CreateBitmap() wants because the order of bytes in the
 301         // line is inversed!
 302         const size_t bytesPerLine = (width + 7) / 8;
 303         const size_t padding = bytesPerLine % 2;
 304         const size_t len = height * ( padding + bytesPerLine );
 305         data = (char *)malloc(len);
 306         const char *src = bits;
 307         char *dst = data;
 308
 309         for ( int rows = 0; rows < height; rows++ )
 310         {
 311             for ( size_t cols = 0; cols < bytesPerLine; cols++ )
 312             {
 313                 unsigned char val = *src++;
 314                 unsigned char reversed = 0;
 315
 316                 for ( int bits = 0; bits < 8; bits++)
 317                 {
 318                     reversed <<= 1;
 319                     reversed |= (val & 0x01);
 320                     val >>= 1;
 321                 }
 322                 *dst++ = reversed;
 323             }
 324
 325             if ( padding )
 326                 *dst++ = 0;
 327         }
 328     }
 329     else
 330     {
 331         // bits should already be in Windows standard format
 332         data = (char *)bits;    // const_cast is harmless
 333     }
 334
 335     HBITMAP hbmp = ::CreateBitmap(width, height, 1, depth, data);
 336     if ( !hbmp )
 337     {
 338         wxLogLastError(wxT("CreateBitmap"));
 339     }
 340
 341     if ( data != bits )
 342     {
 343         free(data);
 344     }
 345
 346     SetHBITMAP((WXHBITMAP)hbmp);
 347 #endif
 348 }
 349
 350 // Create from XPM data
 351 bool wxBitmap::CreateFromXpm(const char **data)
 352 {
 353 #if wxUSE_IMAGE && wxUSE_XPM
 354     Init();
 355
 356     wxCHECK_MSG( data != NULL, FALSE, wxT("invalid bitmap data") )
 357
 358     wxXPMDecoder decoder;
 359     wxImage img = decoder.ReadData(data);
 360     wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid bitmap data") )
 361
 362     *this = wxBitmap(img);
 363     return TRUE;
 364 #else
 365     return FALSE;
 366 #endif
 367 }
 368
 369 wxBitmap::wxBitmap(int w, int h, int d)
 370 {
 371     Init();
 372
 373     (void)Create(w, h, d);
 374 }
 375
 376 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 377 {
 378     Init();
 379
 380     (void)Create(data, type, width, height, depth);
 381 }
 382
 383 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 384 {
 385     Init();
 386
 387     LoadFile(filename, (int)type);
 388 }
 389
 390 bool wxBitmap::Create(int w, int h, int d)
 391 {
 392     UnRef();
 393
 394     m_refData = new wxBitmapRefData;
 395
 396 #if wxUSE_DIB_FOR_BITMAP
 397     if ( w && h && d >= 16 )
 398     {
 399         if ( !CreateDIB(w, h, d) )
 400            return FALSE;
 401     }
 402     else
 403 #endif // wxUSE_DIB_FOR_BITMAP
 404     {
 405         GetBitmapData()->m_width = w;
 406         GetBitmapData()->m_height = h;
 407         GetBitmapData()->m_depth = d;
 408
 409         HBITMAP hbmp;
 410 #ifndef __WXMICROWIN__
 411         if ( d > 0 )
 412         {
 413             hbmp = ::CreateBitmap(w, h, 1, d, NULL);
 414             if ( !hbmp )
 415             {
 416                 wxLogLastError(wxT("CreateBitmap"));
 417             }
 418         }
 419         else
 420 #endif // !__WXMICROWIN__
 421         {
 422             ScreenHDC dc;
 423             hbmp = ::CreateCompatibleBitmap(dc, w, h);
 424             if ( !hbmp )
 425             {
 426                 wxLogLastError(wxT("CreateCompatibleBitmap"));
 427             }
 428
 429             GetBitmapData()->m_depth = wxDisplayDepth();
 430         }
 431
 432         SetHBITMAP((WXHBITMAP)hbmp);
 433
 434 #if WXWIN_COMPATIBILITY_2
 435         GetBitmapData()->m_ok = hbmp != 0;
 436 #endif // WXWIN_COMPATIBILITY_2
 437     }
 438
 439     return Ok();
 440 }
 441
 442 #if wxUSE_IMAGE
 443
 444 // ----------------------------------------------------------------------------
 445 // wxImage to/from conversions for Microwin
 446 // ----------------------------------------------------------------------------
 447
 448 // Microwin versions are so different from normal ones that it really doesn't
 449 // make sense to use #ifdefs inside the function bodies
 450 #ifdef __WXMICROWIN__
 451
 452 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 453 {
 454     // Set this to 1 to experiment with mask code,
 455     // which currently doesn't work
 456     #define USE_MASKS 0
 457
 458     m_refData = new wxBitmapRefData();
 459
 460     // Initial attempt at a simple-minded implementation.
 461     // The bitmap will always be created at the screen depth,
 462     // so the 'depth' argument is ignored.
 463
 464     HDC hScreenDC = ::GetDC(NULL);
 465     int screenDepth = ::GetDeviceCaps(hScreenDC, BITSPIXEL);
 466
 467     HBITMAP hBitmap = ::CreateCompatibleBitmap(hScreenDC, image.GetWidth(), image.GetHeight());
 468     HBITMAP hMaskBitmap = NULL;
 469     HBITMAP hOldMaskBitmap = NULL;
 470     HDC hMaskDC = NULL;
 471     unsigned char maskR = 0;
 472     unsigned char maskG = 0;
 473     unsigned char maskB = 0;
 474
 475     //    printf("Created bitmap %d\n", (int) hBitmap);
 476     if (hBitmap == NULL)
 477     {
 478         ::ReleaseDC(NULL, hScreenDC);
 479         return FALSE;
 480     }
 481     HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
 482
 483     HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
 484     ::ReleaseDC(NULL, hScreenDC);
 485
 486     // created an mono-bitmap for the possible mask
 487     bool hasMask = image.HasMask();
 488
 489     if ( hasMask )
 490     {
 491 #if USE_MASKS
 492         // FIXME: we should be able to pass bpp = 1, but
 493         // GdBlit can't handle a different depth
 494 #if 0
 495         hMaskBitmap = ::CreateBitmap( (WORD)image.GetWidth(), (WORD)image.GetHeight(), 1, 1, NULL );
 496 #else
 497         hMaskBitmap = ::CreateCompatibleBitmap( hMemDC, (WORD)image.GetWidth(), (WORD)image.GetHeight());
 498 #endif
 499         maskR = image.GetMaskRed();
 500         maskG = image.GetMaskGreen();
 501         maskB = image.GetMaskBlue();
 502
 503         if (!hMaskBitmap)
 504         {
 505             hasMask = FALSE;
 506         }
 507         else
 508         {
 509             hScreenDC = ::GetDC(NULL);
 510             hMaskDC = ::CreateCompatibleDC(hScreenDC);
 511            ::ReleaseDC(NULL, hScreenDC);
 512
 513             hOldMaskBitmap = ::SelectObject( hMaskDC, hMaskBitmap);
 514         }
 515 #else
 516         hasMask = FALSE;
 517 #endif
 518     }
 519
 520     int i, j;
 521     for (i = 0; i < image.GetWidth(); i++)
 522     {
 523         for (j = 0; j < image.GetHeight(); j++)
 524         {
 525             unsigned char red = image.GetRed(i, j);
 526             unsigned char green = image.GetGreen(i, j);
 527             unsigned char blue = image.GetBlue(i, j);
 528
 529             ::SetPixel(hMemDC, i, j, PALETTERGB(red, green, blue));
 530
 531             if (hasMask)
 532             {
 533                 // scan the bitmap for the transparent colour and set the corresponding
 534                 // pixels in the mask to BLACK and the rest to WHITE
 535                 if (maskR == red && maskG == green && maskB == blue)
 536                     ::SetPixel(hMaskDC, i, j, PALETTERGB(0, 0, 0));
 537                 else
 538                     ::SetPixel(hMaskDC, i, j, PALETTERGB(255, 255, 255));
 539             }
 540         }
 541     }
 542
 543     ::SelectObject(hMemDC, hOldBitmap);
 544     ::DeleteDC(hMemDC);
 545     if (hasMask)
 546     {
 547         ::SelectObject(hMaskDC, hOldMaskBitmap);
 548         ::DeleteDC(hMaskDC);
 549
 550         ((wxBitmapRefData*)m_refData)->SetMask(hMaskBitmap);
 551     }
 552
 553     SetWidth(image.GetWidth());
 554     SetHeight(image.GetHeight());
 555     SetDepth(screenDepth);
 556     SetHBITMAP( (WXHBITMAP) hBitmap );
 557
 558 #if wxUSE_PALETTE
 559     // Copy the palette from the source image
 560     SetPalette(image.GetPalette());
 561 #endif // wxUSE_PALETTE
 562
 563 #if WXWIN_COMPATIBILITY_2
 564     // check the wxBitmap object
 565     GetBitmapData()->SetOk();
 566 #endif // WXWIN_COMPATIBILITY_2
 567
 568     return TRUE;
 569 }
 570
 571 wxImage wxBitmap::ConvertToImage() const
 572 {
 573     // Initial attempt at a simple-minded implementation.
 574     // The bitmap will always be created at the screen depth,
 575     // so the 'depth' argument is ignored.
 576     // TODO: transparency (create a mask image)
 577
 578     if (!Ok())
 579     {
 580         wxFAIL_MSG( wxT("bitmap is invalid") );
 581         return wxNullImage;
 582     }
 583
 584     wxImage image;
 585
 586     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 587
 588     // create an wxImage object
 589     int width = GetWidth();
 590     int height = GetHeight();
 591     image.Create( width, height );
 592     unsigned char *data = image.GetData();
 593     if( !data )
 594     {
 595         wxFAIL_MSG( wxT("could not allocate data for image") );
 596         return wxNullImage;
 597     }
 598
 599     HDC hScreenDC = ::GetDC(NULL);
 600
 601     HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
 602     ::ReleaseDC(NULL, hScreenDC);
 603
 604     HBITMAP hBitmap = (HBITMAP) GetHBITMAP();
 605
 606     HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
 607
 608     int i, j;
 609     for (i = 0; i < GetWidth(); i++)
 610     {
 611         for (j = 0; j < GetHeight(); j++)
 612         {
 613             COLORREF color = ::GetPixel(hMemDC, i, j);
 614             unsigned char red = GetRValue(color);
 615             unsigned char green = GetGValue(color);
 616             unsigned char blue = GetBValue(color);
 617
 618             image.SetRGB(i, j, red, green, blue);
 619         }
 620     }
 621
 622     ::SelectObject(hMemDC, hOldBitmap);
 623     ::DeleteDC(hMemDC);
 624
 625 #if wxUSE_PALETTE
 626     // Copy the palette from the source image
 627     if (GetPalette())
 628         image.SetPalette(* GetPalette());
 629 #endif // wxUSE_PALETTE
 630
 631     return image;
 632 }
 633
 634 #endif // __WXMICROWIN__
 635
 636 // ----------------------------------------------------------------------------
 637 // wxImage to/from conversions
 638 // ----------------------------------------------------------------------------
 639
 640 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 641 {
 642     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") );
 643
 644     UnRef();
 645
 646     // first convert the image to DIB
 647     const int h = image.GetHeight();
 648     const int w = image.GetWidth();
 649
 650     wxDIB dib(image);
 651     if ( !dib.IsOk() )
 652         return FALSE;
 653
 654
 655     // store the bitmap parameters
 656     wxBitmapRefData *refData = new wxBitmapRefData;
 657     refData->m_width = w;
 658     refData->m_height = h;
 659     refData->m_depth = dib.GetDepth();
 660     refData->m_hasAlpha = image.HasAlpha();
 661
 662     m_refData = refData;
 663
 664
 665     // next either store DIB as is or create a DDB from it
 666     HBITMAP hbitmap;
 667
 668     // TODO: if we're ready to use DIB as is, we can just do this:
 669     // if ( ... )
 670     //  hbitmap = dib.Detach();
 671     // else
 672     {
 673         // create and set the device-dependent bitmap
 674         //
 675         // VZ: why don't we just use SetDIBits() instead? because of the
 676         //     palette or is there some other reason?
 677         hbitmap = ::CreateCompatibleBitmap(ScreenHDC(), w, h);
 678         if ( !hbitmap )
 679         {
 680             wxLogLastError(_T("CreateCompatibleBitmap()"));
 681
 682             return FALSE;
 683         }
 684
 685         MemoryHDC hdcMem;
 686         SelectInHDC select(hdcMem, hbitmap);
 687         if ( !select )
 688         {
 689             wxLogLastError(_T("SelectObjct(hBitmap)"));
 690         }
 691
 692 #if wxUSE_PALETTE
 693         const wxPalette& palette = image.GetPalette();
 694
 695         HPALETTE hOldPalette;
 696         if ( palette.Ok() )
 697         {
 698             SetPalette(palette);
 699
 700             hOldPalette = ::SelectPalette
 701                             (
 702                                 hdcMem,
 703                                 GetHpaletteOf(palette),
 704                                 FALSE                   // ignored for hdcMem
 705                             );
 706
 707             if ( !hOldPalette )
 708             {
 709                 wxLogLastError(_T("SelectPalette()"));
 710             }
 711
 712             if ( ::RealizePalette(hdcMem) == GDI_ERROR )
 713             {
 714                 wxLogLastError(_T("RealizePalette()"));
 715             }
 716         }
 717         else // no valid palette
 718         {
 719             hOldPalette = 0;
 720         }
 721 #endif // wxUSE_PALETTE
 722
 723         DIBSECTION ds;
 724         if ( !::GetObject(dib.GetHandle(), sizeof(ds), &ds) )
 725         {
 726             wxLogLastError(_T("GetObject(hDIB)"));
 727         }
 728
 729         if ( ::StretchDIBits(hdcMem,
 730                              0, 0, w, h,
 731                              0, 0, w, h,
 732                              dib.GetData(),
 733                              (BITMAPINFO *)&ds.dsBmih,
 734                              DIB_RGB_COLORS,
 735                              SRCCOPY) == GDI_ERROR )
 736         {
 737             wxLogLastError(_T("StretchDIBits()"));
 738
 739             return FALSE;
 740         }
 741
 742 #if wxUSE_PALETTE
 743         if ( hOldPalette )
 744         {
 745             ::SelectPalette(hdcMem, hOldPalette, FALSE);
 746         }
 747 #endif // wxUSE_PALETTE
 748     }
 749
 750     // validate this object
 751     SetHBITMAP((WXHBITMAP)hbitmap);
 752
 753 #if WXWIN_COMPATIBILITY_2
 754     m_refData->m_ok = TRUE;
 755 #endif // WXWIN_COMPATIBILITY_2
 756
 757     // finally also set the mask if we have one
 758     if ( image.HasMask() )
 759     {
 760         SetMask(new wxMask(*this, wxColour(image.GetMaskRed(),
 761                                            image.GetMaskGreen(),
 762                                            image.GetMaskBlue())));
 763     }
 764
 765     return TRUE;
 766 }
 767
 768 wxImage wxBitmap::ConvertToImage() const
 769 {
 770     wxImage image;
 771
 772     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 773
 774     // create an wxImage object
 775     int width = GetWidth();
 776     int height = GetHeight();
 777     image.Create( width, height );
 778     unsigned char *data = image.GetData();
 779     if( !data )
 780     {
 781         wxFAIL_MSG( wxT("could not allocate data for image") );
 782         return wxNullImage;
 783     }
 784
 785     // calc the number of bytes per scanline and padding in the DIB
 786     int bytePerLine = width*3;
 787     int sizeDWORD = sizeof( DWORD );
 788     int lineBoundary =  bytePerLine % sizeDWORD;
 789     int padding = 0;
 790     if( lineBoundary > 0 )
 791     {
 792         padding = sizeDWORD - lineBoundary;
 793         bytePerLine += padding;
 794     }
 795
 796     // create a DIB header
 797     int headersize = sizeof(BITMAPINFOHEADER);
 798     BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
 799     if( !lpDIBh )
 800     {
 801         wxFAIL_MSG( wxT("could not allocate data for DIB header") );
 802         free( data );
 803         return wxNullImage;
 804     }
 805     // Fill in the DIB header
 806     lpDIBh->bmiHeader.biSize = headersize;
 807     lpDIBh->bmiHeader.biWidth = width;
 808     lpDIBh->bmiHeader.biHeight = -height;
 809     lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
 810     lpDIBh->bmiHeader.biPlanes = 1;
 811     lpDIBh->bmiHeader.biBitCount = 24;
 812     lpDIBh->bmiHeader.biCompression = BI_RGB;
 813     lpDIBh->bmiHeader.biClrUsed = 0;
 814     // These seem not really needed for our purpose here.
 815     lpDIBh->bmiHeader.biClrImportant = 0;
 816     lpDIBh->bmiHeader.biXPelsPerMeter = 0;
 817     lpDIBh->bmiHeader.biYPelsPerMeter = 0;
 818     // memory for DIB data
 819     unsigned char *lpBits;
 820     lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
 821     if( !lpBits )
 822     {
 823         wxFAIL_MSG( wxT("could not allocate data for DIB") );
 824         free( data );
 825         free( lpDIBh );
 826         return wxNullImage;
 827     }
 828
 829     // copy data from the device-dependent bitmap to the DIB
 830     HDC hdc = ::GetDC(NULL);
 831     HBITMAP hbitmap;
 832     hbitmap = (HBITMAP) GetHBITMAP();
 833     ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
 834
 835     // copy DIB data into the wxImage object
 836     int i, j;
 837     unsigned char *ptdata = data;
 838     unsigned char *ptbits = lpBits;
 839     for( i=0; i<height; i++ )
 840     {
 841         for( j=0; j<width; j++ )
 842         {
 843             *(ptdata++) = *(ptbits+2);
 844             *(ptdata++) = *(ptbits+1);
 845             *(ptdata++) = *(ptbits  );
 846             ptbits += 3;
 847         }
 848         ptbits += padding;
 849     }
 850
 851     // similarly, set data according to the possible mask bitmap
 852     if( GetMask() && GetMask()->GetMaskBitmap() )
 853     {
 854         hbitmap = (HBITMAP) GetMask()->GetMaskBitmap();
 855         // memory DC created, color set, data copied, and memory DC deleted
 856         HDC memdc = ::CreateCompatibleDC( hdc );
 857         ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
 858         ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
 859         ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
 860         ::DeleteDC( memdc );
 861         // background color set to RGB(16,16,16) in consistent with wxGTK
 862         unsigned char r=16, g=16, b=16;
 863         ptdata = data;
 864         ptbits = lpBits;
 865         for( i=0; i<height; i++ )
 866         {
 867             for( j=0; j<width; j++ )
 868             {
 869                 if( *ptbits != 0 )
 870                     ptdata += 3;
 871                 else
 872                 {
 873                     *(ptdata++)  = r;
 874                     *(ptdata++)  = g;
 875                     *(ptdata++)  = b;
 876                 }
 877                 ptbits += 3;
 878             }
 879             ptbits += padding;
 880         }
 881         image.SetMaskColour( r, g, b );
 882         image.SetMask( TRUE );
 883     }
 884     else
 885     {
 886         image.SetMask( FALSE );
 887     }
 888     // free allocated resources
 889     ::ReleaseDC(NULL, hdc);
 890     free(lpDIBh);
 891     free(lpBits);
 892
 893     return image;
 894 }
 895
 896 #endif // wxUSE_IMAGE
 897
 898 // ----------------------------------------------------------------------------
 899 // loading and saving bitmaps
 900 // ----------------------------------------------------------------------------
 901
 902 bool wxBitmap::LoadFile(const wxString& filename, long type)
 903 {
 904     UnRef();
 905
 906     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 907
 908     if ( handler )
 909     {
 910         m_refData = new wxBitmapRefData;
 911
 912         return handler->LoadFile(this, filename, type, -1, -1);
 913     }
 914 #if wxUSE_IMAGE
 915     else
 916     {
 917         wxImage image;
 918         if ( image.LoadFile( filename, type ) && image.Ok() )
 919         {
 920             *this = wxBitmap(image);
 921
 922             return TRUE;
 923         }
 924     }
 925 #endif // wxUSE_IMAGE
 926
 927     return FALSE;
 928 }
 929
 930 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 931 {
 932     UnRef();
 933
 934     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 935
 936     if ( !handler )
 937     {
 938         wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), type);
 939
 940         return FALSE;
 941     }
 942
 943     m_refData = new wxBitmapRefData;
 944
 945     return handler->Create(this, data, type, width, height, depth);
 946 }
 947
 948 bool wxBitmap::SaveFile(const wxString& filename,
 949                         int type,
 950                         const wxPalette *palette)
 951 {
 952     wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
 953
 954     if ( handler )
 955     {
 956         return handler->SaveFile(this, filename, type, palette);
 957     }
 958 #if wxUSE_IMAGE
 959     else
 960     {
 961         // FIXME what about palette? shouldn't we use it?
 962         wxImage image = ConvertToImage();
 963         if ( image.Ok() )
 964         {
 965             return image.SaveFile(filename, type);
 966         }
 967     }
 968 #endif // wxUSE_IMAGE
 969
 970     return FALSE;
 971 }
 972
 973 // ----------------------------------------------------------------------------
 974 // sub bitmap extraction
 975 // ----------------------------------------------------------------------------
 976
 977 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 978 {
 979     wxCHECK_MSG( Ok() &&
 980                  (rect.x >= 0) && (rect.y >= 0) &&
 981                  (rect.x+rect.width <= GetWidth()) &&
 982                  (rect.y+rect.height <= GetHeight()),
 983                  wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
 984
 985     wxBitmap ret( rect.width, rect.height );
 986     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 987
 988 #ifndef __WXMICROWIN__
 989     // TODO: copy alpha channel data if any
 990
 991     // copy bitmap data
 992     MemoryHDC dcSrc,
 993               dcDst;
 994
 995     {
 996         SelectInHDC selectSrc(dcSrc, GetHbitmap()),
 997                     selectDst(dcDst, GetHbitmapOf(ret));
 998
 999         if ( !selectSrc || !selectDst )
1000         {
1001             wxLogLastError(_T("SelectObjct(hBitmap)"));
1002         }
1003
1004         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
1005                        dcSrc, rect.x, rect.y, SRCCOPY) )
1006         {
1007             wxLogLastError(_T("BitBlt"));
1008         }
1009     }
1010
1011     // copy mask if there is one
1012     if ( GetMask() )
1013     {
1014         HBITMAP hbmpMask = ::CreateBitmap(rect.width, rect.height, 1, 1, 0);
1015
1016         SelectInHDC selectSrc(dcSrc, (HBITMAP) GetMask()->GetMaskBitmap()),
1017                     selectDst(dcDst, hbmpMask);
1018
1019         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
1020                        dcSrc, rect.x, rect.y, SRCCOPY) )
1021         {
1022             wxLogLastError(_T("BitBlt"));
1023         }
1024
1025         wxMask *mask = new wxMask((WXHBITMAP) hbmpMask);
1026         ret.SetMask(mask);
1027     }
1028 #endif // !__WXMICROWIN__
1029
1030     return ret;
1031 }
1032
1033 // ----------------------------------------------------------------------------
1034 // wxBitmap accessors
1035 // ----------------------------------------------------------------------------
1036
1037 wxPalette* wxBitmap::GetPalette() const
1038 {
1039     return GetBitmapData() ? &GetBitmapData()->m_bitmapPalette
1040                            : (wxPalette *) NULL;
1041 }
1042
1043 wxMask *wxBitmap::GetMask() const
1044 {
1045     return GetBitmapData() ? GetBitmapData()->GetMask() : (wxMask *) NULL;
1046 }
1047
1048 #ifdef __WXDEBUG__
1049
1050 wxDC *wxBitmap::GetSelectedInto() const
1051 {
1052     return GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC *) NULL;
1053 }
1054
1055 #endif
1056
1057 #if WXWIN_COMPATIBILITY_2_4
1058
1059 int wxBitmap::GetQuality() const
1060 {
1061     return 0;
1062 }
1063
1064 #endif // WXWIN_COMPATIBILITY_2_4
1065
1066 bool wxBitmap::HasAlpha() const
1067 {
1068     return GetBitmapData() && GetBitmapData()->m_hasAlpha;
1069 }
1070
1071 // ----------------------------------------------------------------------------
1072 // wxBitmap setters
1073 // ----------------------------------------------------------------------------
1074
1075 #ifdef __WXDEBUG__
1076
1077 void wxBitmap::SetSelectedInto(wxDC *dc)
1078 {
1079     if ( GetBitmapData() )
1080         GetBitmapData()->m_selectedInto = dc;
1081 }
1082
1083 #endif
1084
1085 #if wxUSE_PALETTE
1086
1087 void wxBitmap::SetPalette(const wxPalette& palette)
1088 {
1089     EnsureHasData();
1090
1091     GetBitmapData()->m_bitmapPalette = palette;
1092 }
1093
1094 #endif // wxUSE_PALETTE
1095
1096 void wxBitmap::SetMask(wxMask *mask)
1097 {
1098     EnsureHasData();
1099
1100     GetBitmapData()->SetMask(mask);
1101 }
1102
1103 #if WXWIN_COMPATIBILITY_2
1104
1105 void wxBitmap::SetOk(bool isOk)
1106 {
1107     EnsureHasData();
1108
1109     GetBitmapData()->m_ok = isOk;
1110 }
1111
1112 #endif // WXWIN_COMPATIBILITY_2
1113
1114 #if WXWIN_COMPATIBILITY_2_4
1115
1116 void wxBitmap::SetQuality(int WXUNUSED(quality))
1117 {
1118 }
1119
1120 #endif // WXWIN_COMPATIBILITY_2_4
1121
1122 // ----------------------------------------------------------------------------
1123 // TODO: to be replaced by something better
1124 // ----------------------------------------------------------------------------
1125
1126 // Creates a bitmap that matches the device context, from
1127 // an arbitray bitmap. At present, the original bitmap must have an
1128 // associated palette. TODO: use a default palette if no palette exists.
1129 // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
1130 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
1131 {
1132 #ifdef __WXMICROWIN__
1133     return *this;
1134 #else
1135     wxMemoryDC      memDC;
1136     wxBitmap        tmpBitmap(GetWidth(), GetHeight(), dc.GetDepth());
1137     HPALETTE        hPal = (HPALETTE) NULL;
1138     LPBITMAPINFO    lpDib;
1139     void            *lpBits = (void*) NULL;
1140
1141 #if wxUSE_PALETTE
1142     if( GetPalette() && GetPalette()->Ok() )
1143     {
1144         tmpBitmap.SetPalette(*GetPalette());
1145         memDC.SelectObject(tmpBitmap);
1146         memDC.SetPalette(*GetPalette());
1147         hPal = (HPALETTE)GetPalette()->GetHPALETTE();
1148     }
1149     else
1150     {
1151         hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
1152         wxPalette palette;
1153         palette.SetHPALETTE( (WXHPALETTE)hPal );
1154         tmpBitmap.SetPalette( palette );
1155         memDC.SelectObject(tmpBitmap);
1156         memDC.SetPalette( palette );
1157     }
1158 #else // !wxUSE_PALETTE
1159     hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
1160 #endif // wxUSE_PALETTE/!wxUSE_PALETTE
1161
1162     // set the height negative because in a DIB the order of the lines is
1163     // reversed
1164     if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
1165     {
1166         return wxNullBitmap;
1167     }
1168
1169     lpBits = malloc(lpDib->bmiHeader.biSizeImage);
1170
1171     ::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits);
1172
1173     ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
1174                         GetWidth(), GetHeight(),
1175                         0, 0, 0, GetHeight(),
1176                         lpBits, lpDib, DIB_RGB_COLORS);
1177
1178     free(lpBits);
1179
1180     wxFreeDIB(lpDib);
1181
1182     return tmpBitmap;
1183 #endif
1184 }
1185
1186 // ----------------------------------------------------------------------------
1187 // wxMask
1188 // ----------------------------------------------------------------------------
1189
1190 wxMask::wxMask()
1191 {
1192     m_maskBitmap = 0;
1193 }
1194
1195 // Construct a mask from a bitmap and a colour indicating
1196 // the transparent area
1197 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
1198 {
1199     m_maskBitmap = 0;
1200     Create(bitmap, colour);
1201 }
1202
1203 // Construct a mask from a bitmap and a palette index indicating
1204 // the transparent area
1205 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
1206 {
1207     m_maskBitmap = 0;
1208     Create(bitmap, paletteIndex);
1209 }
1210
1211 // Construct a mask from a mono bitmap (copies the bitmap).
1212 wxMask::wxMask(const wxBitmap& bitmap)
1213 {
1214     m_maskBitmap = 0;
1215     Create(bitmap);
1216 }
1217
1218 wxMask::~wxMask()
1219 {
1220     if ( m_maskBitmap )
1221         ::DeleteObject((HBITMAP) m_maskBitmap);
1222 }
1223
1224 // Create a mask from a mono bitmap (copies the bitmap).
1225 bool wxMask::Create(const wxBitmap& bitmap)
1226 {
1227 #ifndef __WXMICROWIN__
1228     wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, FALSE,
1229                  _T("can't create mask from invalid or not monochrome bitmap") );
1230
1231     if ( m_maskBitmap )
1232     {
1233         ::DeleteObject((HBITMAP) m_maskBitmap);
1234         m_maskBitmap = 0;
1235     }
1236
1237     m_maskBitmap = (WXHBITMAP) CreateBitmap(
1238                                             bitmap.GetWidth(),
1239                                             bitmap.GetHeight(),
1240                                             1, 1, 0
1241                                            );
1242     HDC srcDC = CreateCompatibleDC(0);
1243     SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
1244     HDC destDC = CreateCompatibleDC(0);
1245     SelectObject(destDC, (HBITMAP) m_maskBitmap);
1246     BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
1247     SelectObject(srcDC, 0);
1248     DeleteDC(srcDC);
1249     SelectObject(destDC, 0);
1250     DeleteDC(destDC);
1251     return TRUE;
1252 #else
1253     return FALSE;
1254 #endif
1255 }
1256
1257 // Create a mask from a bitmap and a palette index indicating
1258 // the transparent area
1259 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
1260 {
1261     if ( m_maskBitmap )
1262     {
1263         ::DeleteObject((HBITMAP) m_maskBitmap);
1264         m_maskBitmap = 0;
1265     }
1266
1267 #if wxUSE_PALETTE
1268     if (bitmap.Ok() && bitmap.GetPalette()->Ok())
1269     {
1270         unsigned char red, green, blue;
1271         if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
1272         {
1273             wxColour transparentColour(red, green, blue);
1274             return Create(bitmap, transparentColour);
1275         }
1276     }
1277 #endif // wxUSE_PALETTE
1278
1279     return FALSE;
1280 }
1281
1282 // Create a mask from a bitmap and a colour indicating
1283 // the transparent area
1284 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
1285 {
1286 #ifndef __WXMICROWIN__
1287     wxCHECK_MSG( bitmap.Ok(), FALSE, _T("invalid bitmap in wxMask::Create") );
1288
1289     if ( m_maskBitmap )
1290     {
1291         ::DeleteObject((HBITMAP) m_maskBitmap);
1292         m_maskBitmap = 0;
1293     }
1294
1295     int width = bitmap.GetWidth(),
1296         height = bitmap.GetHeight();
1297
1298     // scan the bitmap for the transparent colour and set the corresponding
1299     // pixels in the mask to BLACK and the rest to WHITE
1300     COLORREF maskColour = wxColourToPalRGB(colour);
1301     m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0);
1302
1303     HDC srcDC = ::CreateCompatibleDC(NULL);
1304     HDC destDC = ::CreateCompatibleDC(NULL);
1305     if ( !srcDC || !destDC )
1306     {
1307         wxLogLastError(wxT("CreateCompatibleDC"));
1308     }
1309
1310     bool ok = TRUE;
1311
1312     // SelectObject() will fail
1313     wxASSERT_MSG( !bitmap.GetSelectedInto(),
1314                   _T("bitmap can't be selected in another DC") );
1315
1316     HGDIOBJ hbmpSrcOld = ::SelectObject(srcDC, GetHbitmapOf(bitmap));
1317     if ( !hbmpSrcOld )
1318     {
1319         wxLogLastError(wxT("SelectObject"));
1320
1321         ok = FALSE;
1322     }
1323
1324     HGDIOBJ hbmpDstOld = ::SelectObject(destDC, (HBITMAP)m_maskBitmap);
1325     if ( !hbmpDstOld )
1326     {
1327         wxLogLastError(wxT("SelectObject"));
1328
1329         ok = FALSE;
1330     }
1331
1332     if ( ok )
1333     {
1334         // this will create a monochrome bitmap with 0 points for the pixels
1335         // which have the same value as the background colour and 1 for the
1336         // others
1337         ::SetBkColor(srcDC, maskColour);
1338         ::BitBlt(destDC, 0, 0, width, height, srcDC, 0, 0, NOTSRCCOPY);
1339     }
1340
1341     ::SelectObject(srcDC, hbmpSrcOld);
1342     ::DeleteDC(srcDC);
1343     ::SelectObject(destDC, hbmpDstOld);
1344     ::DeleteDC(destDC);
1345
1346     return ok;
1347 #else // __WXMICROWIN__
1348     return FALSE;
1349 #endif // __WXMICROWIN__/!__WXMICROWIN__
1350 }
1351
1352 // ----------------------------------------------------------------------------
1353 // wxBitmapHandler
1354 // ----------------------------------------------------------------------------
1355
1356 bool wxBitmapHandler::Create(wxGDIImage *image,
1357                              void *data,
1358                              long flags,
1359                              int width, int height, int depth)
1360 {
1361     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1362
1363     return bitmap ? Create(bitmap, data, flags, width, height, depth) : FALSE;
1364 }
1365
1366 bool wxBitmapHandler::Load(wxGDIImage *image,
1367                            const wxString& name,
1368                            long flags,
1369                            int width, int height)
1370 {
1371     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1372
1373     return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE;
1374 }
1375
1376 bool wxBitmapHandler::Save(wxGDIImage *image,
1377                            const wxString& name,
1378                            int type)
1379 {
1380     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1381
1382     return bitmap ? SaveFile(bitmap, name, type) : FALSE;
1383 }
1384
1385 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
1386                              void *WXUNUSED(data),
1387                              long WXUNUSED(type),
1388                              int WXUNUSED(width),
1389                              int WXUNUSED(height),
1390                              int WXUNUSED(depth))
1391 {
1392     return FALSE;
1393 }
1394
1395 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
1396                                const wxString& WXUNUSED(name),
1397                                long WXUNUSED(type),
1398                                int WXUNUSED(desiredWidth),
1399                                int WXUNUSED(desiredHeight))
1400 {
1401     return FALSE;
1402 }
1403
1404 bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
1405                                const wxString& WXUNUSED(name),
1406                                int WXUNUSED(type),
1407                                const wxPalette *WXUNUSED(palette))
1408 {
1409     return FALSE;
1410 }
1411
1412 // ----------------------------------------------------------------------------
1413 // DIB functions
1414 // ----------------------------------------------------------------------------
1415
1416 #ifndef __WXMICROWIN__
1417 bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
1418                  HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
1419 {
1420    unsigned long   i, headerSize;
1421    LPBITMAPINFO    lpDIBheader = NULL;
1422    LPPALETTEENTRY  lpPe = NULL;
1423
1424
1425    // Allocate space for a DIB header
1426    headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
1427    lpDIBheader = (BITMAPINFO *) malloc(headerSize);
1428    lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
1429
1430    GetPaletteEntries(hPal, 0, 256, lpPe);
1431
1432    memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
1433
1434    // Fill in the static parts of the DIB header
1435    lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1436    lpDIBheader->bmiHeader.biWidth = xSize;
1437    lpDIBheader->bmiHeader.biHeight = ySize;
1438    lpDIBheader->bmiHeader.biPlanes = 1;
1439
1440    // this value must be 1, 4, 8 or 24 so PixelDepth can only be
1441    lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
1442    lpDIBheader->bmiHeader.biCompression = BI_RGB;
1443    lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3;
1444    lpDIBheader->bmiHeader.biClrUsed = 256;
1445
1446
1447    // Initialize the DIB palette
1448    for (i = 0; i < 256; i++) {
1449       lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
1450       lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
1451       lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
1452       lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
1453    }
1454
1455    *lpDIBHeader = lpDIBheader;
1456
1457    return TRUE;
1458 }
1459
1460 void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
1461 {
1462     free(lpDIBHeader);
1463 }
1464 #endif
1465
1466 // ----------------------------------------------------------------------------
1467 // other helper functions
1468 // ----------------------------------------------------------------------------
1469
1470 extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h)
1471 {
1472 #ifndef __WXMICROWIN__
1473     wxCHECK_MSG( hbmpMask, 0, _T("invalid bitmap in wxInvertMask") );
1474
1475     // get width/height from the bitmap if not given
1476     if ( !w || !h )
1477     {
1478         BITMAP bm;
1479         ::GetObject(hbmpMask, sizeof(BITMAP), (LPVOID)&bm);
1480         w = bm.bmWidth;
1481         h = bm.bmHeight;
1482     }
1483
1484     HDC hdcSrc = ::CreateCompatibleDC(NULL);
1485     HDC hdcDst = ::CreateCompatibleDC(NULL);
1486     if ( !hdcSrc || !hdcDst )
1487     {
1488         wxLogLastError(wxT("CreateCompatibleDC"));
1489     }
1490
1491     HBITMAP hbmpInvMask = ::CreateBitmap(w, h, 1, 1, 0);
1492     if ( !hbmpInvMask )
1493     {
1494         wxLogLastError(wxT("CreateBitmap"));
1495     }
1496
1497     ::SelectObject(hdcSrc, hbmpMask);
1498     ::SelectObject(hdcDst, hbmpInvMask);
1499     if ( !::BitBlt(hdcDst, 0, 0, w, h,
1500                    hdcSrc, 0, 0,
1501                    NOTSRCCOPY) )
1502     {
1503         wxLogLastError(wxT("BitBlt"));
1504     }
1505
1506     ::DeleteDC(hdcSrc);
1507     ::DeleteDC(hdcDst);
1508
1509     return hbmpInvMask;
1510 #else
1511     return 0;
1512 #endif
1513 }