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 #ifdef __GNUG__
  13 #pragma implementation "bitmap.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include <stdio.h>
  25 #include "wx/setup.h"
  26 #include "wx/list.h"
  27 #include "wx/utils.h"
  28 #include "wx/app.h"
  29 #include "wx/palette.h"
  30 #include "wx/bitmap.h"
  31 #include "wx/icon.h"
  32 #endif
  33
  34 #include "wx/msw/private.h"
  35 #include "wx/log.h"
  36
  37 #include "assert.h"
  38
  39 #if wxUSE_XPM_IN_MSW
  40 #define FOR_MSW 1
  41 #include "../src/xpm/xpm34.h"
  42 #endif
  43
  44 #include "wx/msw/dib.h"
  45
  46 #if !USE_SHARED_LIBRARIES
  47 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
  48 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  49 #endif
  50
  51 wxBitmapRefData::wxBitmapRefData(void)
  52 {
  53   m_ok = FALSE;
  54   m_width = 0;
  55   m_height = 0;
  56   m_depth = 0;
  57   m_quality = 0;
  58   m_hBitmap = 0 ;
  59   m_selectedInto = NULL;
  60   m_numColors = 0;
  61   m_bitmapMask = NULL;
  62 }
  63
  64 wxBitmapRefData::~wxBitmapRefData(void)
  65 {
  66   if (m_selectedInto)
  67   {
  68     char buf[200];
  69     sprintf(buf, "Bitmap was deleted without selecting out of wxMemoryDC %X.", (unsigned int) m_selectedInto);
  70     wxFatalError(buf);
  71   }
  72   if (m_hBitmap)
  73   {
  74     DeleteObject((HBITMAP) m_hBitmap);
  75   }
  76   m_hBitmap = 0 ;
  77
  78   if (m_bitmapMask)
  79     delete m_bitmapMask;
  80   m_bitmapMask = NULL;
  81
  82 }
  83
  84 wxList wxBitmap::sm_handlers;
  85
  86 wxBitmap::wxBitmap(void)
  87 {
  88   if ( wxTheBitmapList )
  89     wxTheBitmapList->AddBitmap(this);
  90 }
  91
  92 wxBitmap::~wxBitmap(void)
  93 {
  94     if (wxTheBitmapList)
  95         wxTheBitmapList->DeleteObject(this);
  96 }
  97
  98 bool wxBitmap::FreeResource(bool force)
  99 {
 100   if ( !M_BITMAPDATA )
 101   return FALSE;
 102
 103   if (M_BITMAPDATA->m_selectedInto)
 104   {
 105     char buf[200];
 106     sprintf(buf, "Bitmap %X was deleted without selecting out of wxMemoryDC %X.", (unsigned int) this, (unsigned int) M_BITMAPDATA->m_selectedInto);
 107     wxFatalError(buf);
 108   }
 109   if (M_BITMAPDATA->m_hBitmap)
 110   {
 111     DeleteObject((HBITMAP) M_BITMAPDATA->m_hBitmap);
 112   }
 113   M_BITMAPDATA->m_hBitmap = 0 ;
 114
 115 /*
 116   if (M_BITMAPDATA->m_bitmapPalette)
 117     delete M_BITMAPDATA->m_bitmapPalette;
 118
 119   M_BITMAPDATA->m_bitmapPalette = NULL ;
 120 */
 121
 122   return TRUE;
 123 }
 124
 125
 126 wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
 127 {
 128   m_refData = new wxBitmapRefData;
 129
 130   M_BITMAPDATA->m_width = the_width ;
 131   M_BITMAPDATA->m_height = the_height ;
 132   M_BITMAPDATA->m_depth = no_bits ;
 133   M_BITMAPDATA->m_numColors = 0;
 134
 135   M_BITMAPDATA->m_hBitmap = (WXHBITMAP) CreateBitmap(the_width, the_height, 1, no_bits, bits);
 136
 137   if (M_BITMAPDATA->m_hBitmap)
 138     M_BITMAPDATA->m_ok = TRUE;
 139   else
 140     M_BITMAPDATA->m_ok = FALSE;
 141
 142   M_BITMAPDATA->m_selectedInto = NULL;
 143
 144   if ( wxTheBitmapList )
 145     wxTheBitmapList->AddBitmap(this);
 146 }
 147
 148 wxBitmap::wxBitmap(int w, int h, int d)
 149 {
 150   (void)Create(w, h, d);
 151
 152   if ( wxTheBitmapList )
 153     wxTheBitmapList->AddBitmap(this);
 154 }
 155
 156 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 157 {
 158   (void) Create(data, type, width, height, depth);
 159
 160   if ( wxTheBitmapList )
 161     wxTheBitmapList->AddBitmap(this);
 162 }
 163
 164 wxBitmap::wxBitmap(const wxString& filename, long type)
 165 {
 166   LoadFile(filename, (int)type);
 167
 168   if ( wxTheBitmapList )
 169     wxTheBitmapList->AddBitmap(this);
 170 }
 171
 172 #if wxUSE_XPM_IN_MSW
 173 // Create from data
 174 wxBitmap::wxBitmap(char **data, wxItem *WXUNUSED(anItem))
 175 {
 176   (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
 177 }
 178 #endif
 179
 180 bool wxBitmap::Create(int w, int h, int d)
 181 {
 182   UnRef();
 183
 184   m_refData = new wxBitmapRefData;
 185
 186   M_BITMAPDATA->m_width = w;
 187   M_BITMAPDATA->m_height = h;
 188   M_BITMAPDATA->m_depth = d;
 189
 190   if (d > 0)
 191   {
 192     M_BITMAPDATA->m_hBitmap = (WXHBITMAP) CreateBitmap(w, h, 1, d, NULL);
 193   }
 194   else
 195   {
 196     HDC dc = GetDC(NULL);
 197     M_BITMAPDATA->m_hBitmap = (WXHBITMAP) CreateCompatibleBitmap(dc, w, h);
 198     ReleaseDC(NULL, dc);
 199     M_BITMAPDATA->m_depth = wxDisplayDepth();
 200   }
 201   if (M_BITMAPDATA->m_hBitmap)
 202     M_BITMAPDATA->m_ok = TRUE;
 203   else
 204     M_BITMAPDATA->m_ok = FALSE;
 205   return M_BITMAPDATA->m_ok;
 206 }
 207
 208 bool wxBitmap::LoadFile(const wxString& filename, long type)
 209 {
 210   UnRef();
 211
 212   m_refData = new wxBitmapRefData;
 213
 214   wxBitmapHandler *handler = FindHandler(type);
 215
 216   if ( handler == NULL ) {
 217     wxLogWarning("no bitmap handler for type %d defined.", type);
 218
 219     return FALSE;
 220   }
 221
 222   return handler->LoadFile(this, filename, type, -1, -1);
 223 }
 224
 225 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 226 {
 227   UnRef();
 228
 229   m_refData = new wxBitmapRefData;
 230
 231   wxBitmapHandler *handler = FindHandler(type);
 232
 233   if ( handler == NULL ) {
 234     wxLogWarning("no bitmap handler for type %d defined.", type);
 235
 236     return FALSE;
 237   }
 238
 239   return handler->Create(this, data, type, width, height, depth);
 240 }
 241
 242 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
 243 {
 244   wxBitmapHandler *handler = FindHandler(type);
 245
 246   if ( handler == NULL ) {
 247     wxLogWarning("no bitmap handler for type %d defined.", type);
 248
 249     return FALSE;
 250   }
 251
 252   return handler->SaveFile(this, filename, type, palette);
 253 }
 254
 255 void wxBitmap::SetWidth(int w)
 256 {
 257   if (!M_BITMAPDATA)
 258   m_refData = new wxBitmapRefData;
 259
 260   M_BITMAPDATA->m_width = w;
 261 }
 262
 263 void wxBitmap::SetHeight(int h)
 264 {
 265   if (!M_BITMAPDATA)
 266   m_refData = new wxBitmapRefData;
 267
 268   M_BITMAPDATA->m_height = h;
 269 }
 270
 271 void wxBitmap::SetDepth(int d)
 272 {
 273   if (!M_BITMAPDATA)
 274   m_refData = new wxBitmapRefData;
 275
 276   M_BITMAPDATA->m_depth = d;
 277 }
 278
 279 void wxBitmap::SetQuality(int q)
 280 {
 281   if (!M_BITMAPDATA)
 282   m_refData = new wxBitmapRefData;
 283
 284   M_BITMAPDATA->m_quality = q;
 285 }
 286
 287 void wxBitmap::SetOk(bool isOk)
 288 {
 289   if (!M_BITMAPDATA)
 290   m_refData = new wxBitmapRefData;
 291
 292   M_BITMAPDATA->m_ok = isOk;
 293 }
 294
 295 void wxBitmap::SetPalette(const wxPalette& palette)
 296 {
 297   if (!M_BITMAPDATA)
 298   m_refData = new wxBitmapRefData;
 299
 300   M_BITMAPDATA->m_bitmapPalette = palette ;
 301 }
 302
 303 void wxBitmap::SetMask(wxMask *mask)
 304 {
 305   if (!M_BITMAPDATA)
 306   m_refData = new wxBitmapRefData;
 307
 308   M_BITMAPDATA->m_bitmapMask = mask ;
 309 }
 310
 311 void wxBitmap::SetHBITMAP(WXHBITMAP bmp)
 312 {
 313   if (!M_BITMAPDATA)
 314   m_refData = new wxBitmapRefData;
 315
 316   M_BITMAPDATA->m_hBitmap = bmp;
 317 }
 318
 319 void wxBitmap::AddHandler(wxBitmapHandler *handler)
 320 {
 321   sm_handlers.Append(handler);
 322 }
 323
 324 void wxBitmap::InsertHandler(wxBitmapHandler *handler)
 325 {
 326   sm_handlers.Insert(handler);
 327 }
 328
 329 bool wxBitmap::RemoveHandler(const wxString& name)
 330 {
 331   wxBitmapHandler *handler = FindHandler(name);
 332   if ( handler )
 333   {
 334     sm_handlers.DeleteObject(handler);
 335     return TRUE;
 336   }
 337   else
 338     return FALSE;
 339 }
 340
 341 wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
 342 {
 343   wxNode *node = sm_handlers.First();
 344   while ( node )
 345   {
 346     wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 347     if ( handler->GetName() == name )
 348       return handler;
 349     node = node->Next();
 350   }
 351   return NULL;
 352 }
 353
 354 wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
 355 {
 356   wxNode *node = sm_handlers.First();
 357   while ( node )
 358   {
 359     wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 360     if ( handler->GetExtension() == extension &&
 361           (bitmapType == -1 || handler->GetType() == bitmapType) )
 362       return handler;
 363     node = node->Next();
 364   }
 365   return NULL;
 366 }
 367
 368 wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
 369 {
 370   wxNode *node = sm_handlers.First();
 371   while ( node )
 372   {
 373     wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 374     if (handler->GetType() == bitmapType)
 375       return handler;
 376     node = node->Next();
 377   }
 378   return NULL;
 379 }
 380
 381 // New Create/FreeDIB functions since ones in dibutils.cpp are confusing
 382 static long createDIB(long xSize, long ySize, long bitsPerPixel,
 383                        HPALETTE hPal, LPBITMAPINFO* lpDIBHeader);
 384 static long freeDIB(LPBITMAPINFO lpDIBHeader);
 385
 386 // Creates a bitmap that matches the device context, from
 387 // an arbitray bitmap. At present, the original bitmap must have an
 388 // associated palette. TODO: use a default palette if no palette exists.
 389 // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
 390 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
 391 {
 392     wxMemoryDC      memDC;
 393     wxBitmap        tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
 394     HPALETTE        hPal = NULL;
 395     LPBITMAPINFO    lpDib;
 396     void            *lpBits = NULL;
 397
 398 /*
 399     wxASSERT( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) );
 400
 401     tmpBitmap.SetPalette(this->GetPalette());
 402     memDC.SelectObject(tmpBitmap);
 403     memDC.SetPalette(this->GetPalette());
 404
 405     hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
 406 */
 407     if( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) )
 408     {
 409         tmpBitmap.SetPalette(* this->GetPalette());
 410         memDC.SelectObject(tmpBitmap);
 411         memDC.SetPalette(* this->GetPalette());
 412         hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
 413     }
 414     else
 415     {
 416         hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
 417         wxPalette palette;
 418         palette.SetHPALETTE( (WXHPALETTE)hPal );
 419         tmpBitmap.SetPalette( palette );
 420         memDC.SelectObject(tmpBitmap);
 421         memDC.SetPalette( palette );
 422     }
 423
 424     // set the height negative because in a DIB the order of the lines is reversed
 425     createDIB(this->GetWidth(), -this->GetHeight(), this->GetDepth(), hPal, &lpDib);
 426
 427     lpBits = malloc(lpDib->bmiHeader.biSizeImage);
 428
 429     ::GetBitmapBits((HBITMAP)GetHBITMAP(), lpDib->bmiHeader.biSizeImage, lpBits);
 430
 431     ::SetDIBitsToDevice((HDC) memDC.GetHDC(), 0, 0, this->GetWidth(), this->GetHeight(),
 432                         0, 0, 0, this->GetHeight(), lpBits, lpDib, DIB_RGB_COLORS);
 433
 434     free(lpBits);
 435
 436     freeDIB(lpDib);
 437     return (tmpBitmap);
 438 }
 439
 440 /*
 441  * wxMask
 442  */
 443
 444 wxMask::wxMask(void)
 445 {
 446     m_maskBitmap = 0;
 447 }
 448
 449 // Construct a mask from a bitmap and a colour indicating
 450 // the transparent area
 451 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 452 {
 453     m_maskBitmap = 0;
 454   Create(bitmap, colour);
 455 }
 456
 457 // Construct a mask from a bitmap and a palette index indicating
 458 // the transparent area
 459 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 460 {
 461     m_maskBitmap = 0;
 462   Create(bitmap, paletteIndex);
 463 }
 464
 465 // Construct a mask from a mono bitmap (copies the bitmap).
 466 wxMask::wxMask(const wxBitmap& bitmap)
 467 {
 468     m_maskBitmap = 0;
 469   Create(bitmap);
 470 }
 471
 472 wxMask::~wxMask(void)
 473 {
 474     if ( m_maskBitmap )
 475         ::DeleteObject((HBITMAP) m_maskBitmap);
 476 }
 477
 478 // Create a mask from a mono bitmap (copies the bitmap).
 479 bool wxMask::Create(const wxBitmap& bitmap)
 480 {
 481     if ( m_maskBitmap )
 482   {
 483     ::DeleteObject((HBITMAP) m_maskBitmap);
 484     m_maskBitmap = 0;
 485   }
 486   if (!bitmap.Ok() || bitmap.GetDepth() != 1)
 487   {
 488     return FALSE;
 489   }
 490   m_maskBitmap = (WXHBITMAP) CreateBitmap(
 491           bitmap.GetWidth(),
 492           bitmap.GetHeight(),
 493           1, 1, 0
 494           );
 495   HDC srcDC = CreateCompatibleDC(0);
 496   SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
 497   HDC destDC = CreateCompatibleDC(0);
 498   SelectObject(destDC, (HBITMAP) m_maskBitmap);
 499   BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
 500   SelectObject(srcDC, 0);
 501   DeleteDC(srcDC);
 502   SelectObject(destDC, 0);
 503   DeleteDC(destDC);
 504   return TRUE;
 505 }
 506
 507 // Create a mask from a bitmap and a palette index indicating
 508 // the transparent area
 509 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 510 {
 511     if ( m_maskBitmap )
 512   {
 513     ::DeleteObject((HBITMAP) m_maskBitmap);
 514     m_maskBitmap = 0;
 515   }
 516   if (bitmap.Ok() && bitmap.GetPalette()->Ok())
 517   {
 518     unsigned char red, green, blue;
 519     if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
 520     {
 521       wxColour transparentColour(red, green, blue);
 522       return Create(bitmap, transparentColour);
 523     }
 524   }
 525   return FALSE;
 526 }
 527
 528 // Create a mask from a bitmap and a colour indicating
 529 // the transparent area
 530 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 531 {
 532     if ( m_maskBitmap )
 533   {
 534     ::DeleteObject((HBITMAP) m_maskBitmap);
 535     m_maskBitmap = 0;
 536   }
 537   if (!bitmap.Ok())
 538   {
 539     return FALSE;
 540   }
 541
 542   // scan the bitmap for the transparent colour and set
 543   // the corresponding pixels in the mask to BLACK and
 544   // the rest to WHITE
 545   COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue());
 546   m_maskBitmap = (WXHBITMAP) ::CreateBitmap(
 547           bitmap.GetWidth(),
 548           bitmap.GetHeight(),
 549           1, 1, 0
 550           );
 551   HDC srcDC = ::CreateCompatibleDC(0);
 552   ::SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
 553   HDC destDC = ::CreateCompatibleDC(0);
 554   ::SelectObject(destDC, (HBITMAP) m_maskBitmap);
 555
 556   // this is not very efficient, but I can't think
 557   // of a better way of doing it
 558   for (int w = 0; w < bitmap.GetWidth(); w++)
 559   {
 560     for (int h = 0; h < bitmap.GetHeight(); h++)
 561     {
 562       COLORREF col = GetPixel(srcDC, w, h);
 563       if (col == maskColour)
 564       {
 565         ::SetPixel(destDC, w, h, RGB(0, 0, 0));
 566       }
 567       else
 568       {
 569         ::SetPixel(destDC, w, h, RGB(255, 255, 255));
 570       }
 571     }
 572   }
 573   ::SelectObject(srcDC, 0);
 574   ::DeleteDC(srcDC);
 575   ::SelectObject(destDC, 0);
 576   ::DeleteDC(destDC);
 577   return TRUE;
 578 }
 579
 580 /*
 581  * wxBitmapHandler
 582  */
 583
 584 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 585
 586 bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
 587 {
 588   return FALSE;
 589 }
 590
 591 bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
 592     int desiredWidth, int desiredHeight)
 593 {
 594   return FALSE;
 595 }
 596
 597 bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
 598 {
 599   return FALSE;
 600 }
 601
 602 /*
 603  * Standard handlers
 604  */
 605
 606 class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
 607 {
 608   DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
 609 public:
 610   inline wxBMPResourceHandler(void)
 611   {
 612   m_name = "Windows bitmap resource";
 613   m_extension = "";
 614   m_type = wxBITMAP_TYPE_BMP_RESOURCE;
 615   };
 616
 617   virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 618       int desiredWidth, int desiredHeight);
 619 };
 620 IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
 621
 622 bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 623     int desiredWidth, int desiredHeight)
 624 {
 625     // TODO: load colourmap.
 626     M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ::LoadBitmap(wxGetInstance(), name);
 627     if (M_BITMAPHANDLERDATA->m_hBitmap)
 628     {
 629       M_BITMAPHANDLERDATA->m_ok = TRUE;
 630       BITMAP bm;
 631       GetObject((HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap, sizeof(BITMAP), (LPSTR) &bm);
 632       M_BITMAPHANDLERDATA->m_width = bm.bmWidth;
 633       M_BITMAPHANDLERDATA->m_height = bm.bmHeight;
 634       M_BITMAPHANDLERDATA->m_depth = bm.bmBitsPixel;
 635       return TRUE;
 636     }
 637
 638   // it's probably not found
 639   wxLogError("Can't load bitmap '%s' from resources! Check .rc file.", name.c_str());
 640
 641   return FALSE;
 642 }
 643
 644 class WXDLLEXPORT wxBMPFileHandler: public wxBitmapHandler
 645 {
 646   DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
 647 public:
 648   inline wxBMPFileHandler(void)
 649   {
 650   m_name = "Windows bitmap file";
 651   m_extension = "bmp";
 652   m_type = wxBITMAP_TYPE_BMP;
 653   };
 654
 655   virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 656       int desiredWidth, int desiredHeight);
 657   virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
 658 };
 659 IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
 660
 661 bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 662     int desiredWidth, int desiredHeight)
 663 {
 664 #if wxUSE_IMAGE_LOADING_IN_MSW
 665     wxPalette *palette = NULL;
 666     bool success = FALSE;
 667 /*
 668     if (type & wxBITMAP_DISCARD_COLOURMAP)
 669       success = wxLoadIntoBitmap(WXSTRINGCAST name, bitmap);
 670     else
 671 */
 672     success = (wxLoadIntoBitmap(WXSTRINGCAST name, bitmap, &palette) != 0);
 673     if (!success && palette)
 674     {
 675       delete palette;
 676       palette = NULL;
 677     }
 678     if (palette)
 679       M_BITMAPHANDLERDATA->m_bitmapPalette = *palette;
 680     return success;
 681 #else
 682   return FALSE;
 683 #endif
 684 }
 685
 686 bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *pal)
 687 {
 688 #if wxUSE_IMAGE_LOADING_IN_MSW
 689     wxPalette *actualPalette = (wxPalette *)pal;
 690     if (!actualPalette && (!M_BITMAPHANDLERDATA->m_bitmapPalette.IsNull()))
 691       actualPalette = & (M_BITMAPHANDLERDATA->m_bitmapPalette);
 692     return (wxSaveBitmap(WXSTRINGCAST name, bitmap, actualPalette) != 0);
 693 #else
 694   return FALSE;
 695 #endif
 696 }
 697
 698 class WXDLLEXPORT wxXPMFileHandler: public wxBitmapHandler
 699 {
 700   DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
 701 public:
 702   inline wxXPMFileHandler(void)
 703   {
 704   m_name = "XPM bitmap file";
 705   m_extension = "xpm";
 706   m_type = wxBITMAP_TYPE_XPM;
 707   };
 708
 709   virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 710     int desiredWidth = -1, int desiredHeight = -1);
 711   virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
 712 };
 713 IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
 714
 715 bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
 716     int desiredWidth, int desiredHeight)
 717 {
 718 #if wxUSE_XPM_IN_MSW
 719     XImage *ximage;
 720     XpmAttributes xpmAttr;
 721     HDC     dc;
 722
 723     M_BITMAPHANDLERDATA->m_ok = FALSE;
 724     dc = CreateCompatibleDC(NULL);
 725     if (dc)
 726     {
 727       xpmAttr.valuemask = XpmReturnPixels;
 728       int errorStatus = XpmReadFileToImage(&dc, WXSTRINGCAST name, &ximage, (XImage **) NULL, &xpmAttr);
 729       DeleteDC(dc);
 730       if (errorStatus == XpmSuccess)
 731       {
 732         M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ximage->bitmap;
 733
 734         BITMAP  bm;
 735         GetObject((HBITMAP)M_BITMAPHANDLERDATA->m_hBitmap, sizeof(bm), (LPSTR) & bm);
 736
 737         M_BITMAPHANDLERDATA->m_width = (bm.bmWidth);
 738         M_BITMAPHANDLERDATA->m_height = (bm.bmHeight);
 739         M_BITMAPHANDLERDATA->m_depth = (bm.bmPlanes * bm.bmBitsPixel);
 740         M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
 741         XpmFreeAttributes(&xpmAttr);
 742         XImageFree(ximage);
 743
 744         M_BITMAPHANDLERDATA->m_ok = TRUE;
 745         return TRUE;
 746       }
 747       else
 748       {
 749         M_BITMAPHANDLERDATA->m_ok = FALSE;
 750         return FALSE;
 751       }
 752     }
 753 #endif
 754
 755     return FALSE;
 756 }
 757
 758 bool wxXPMFileHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
 759 {
 760 #if wxUSE_XPM_IN_MSW
 761     HDC     dc = NULL;
 762
 763     XImage  ximage;
 764
 765     dc = CreateCompatibleDC(NULL);
 766     if (dc)
 767     {
 768         if (SelectObject(dc, (HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap))
 769         {
 770             /* for following SetPixel */
 771             /* fill the XImage struct 'by hand' */
 772             ximage.width = M_BITMAPHANDLERDATA->m_width;
 773             ximage.height = M_BITMAPHANDLERDATA->m_height;
 774             ximage.depth = M_BITMAPHANDLERDATA->m_depth;
 775             ximage.bitmap = (HBITMAP)M_BITMAPHANDLERDATA->m_hBitmap;
 776             int errorStatus = XpmWriteFileFromImage(&dc, WXSTRINGCAST name,
 777                 &ximage, (XImage *) NULL, (XpmAttributes *) NULL);
 778
 779             if (dc)
 780                 DeleteDC(dc);
 781
 782             if (errorStatus == XpmSuccess)
 783                 return TRUE;    /* no error */
 784             else
 785                 return FALSE;
 786         } else return FALSE;
 787     } else return FALSE;
 788 #else
 789     return FALSE;
 790 #endif
 791 }
 792
 793 class WXDLLEXPORT wxXPMDataHandler: public wxBitmapHandler
 794 {
 795   DECLARE_DYNAMIC_CLASS(wxXPMDataHandler)
 796 public:
 797   inline wxXPMDataHandler(void)
 798   {
 799   m_name = "XPM bitmap data";
 800   m_extension = "xpm";
 801   m_type = wxBITMAP_TYPE_XPM_DATA;
 802   };
 803
 804   virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
 805 };
 806 IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 807
 808 bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth)
 809 {
 810 #if wxUSE_XPM_IN_MSW
 811   XImage *ximage;
 812   int     ErrorStatus;
 813   XpmAttributes xpmAttr;
 814   HDC     dc;
 815
 816   M_BITMAPHANDLERDATA->m_ok = FALSE;
 817   M_BITMAPHANDLERDATA->m_numColors = 0;
 818
 819   dc = CreateCompatibleDC(NULL);  /* memory DC */
 820
 821   if (dc)
 822   {
 823     xpmAttr.valuemask = XpmReturnInfos; /* get infos back */
 824     ErrorStatus = XpmCreateImageFromData(&dc, (char **)data,
 825          &ximage, (XImage **) NULL, &xpmAttr);
 826
 827     if (ErrorStatus == XpmSuccess)
 828     {
 829       /* ximage is malloced and contains bitmap and attributes */
 830       M_BITMAPHANDLERDATA->m_hBitmap = (WXHBITMAP) ximage->bitmap;
 831
 832       BITMAP  bm;
 833       GetObject((HBITMAP) M_BITMAPHANDLERDATA->m_hBitmap, sizeof(bm), (LPSTR) & bm);
 834
 835       M_BITMAPHANDLERDATA->m_width = (bm.bmWidth);
 836       M_BITMAPHANDLERDATA->m_height = (bm.bmHeight);
 837       M_BITMAPHANDLERDATA->m_depth = (bm.bmPlanes * bm.bmBitsPixel);
 838       M_BITMAPHANDLERDATA->m_numColors = xpmAttr.npixels;
 839       XpmFreeAttributes(&xpmAttr);
 840
 841       XImageFree(ximage); // releases the malloc, but does not detroy
 842                           // the bitmap
 843       M_BITMAPHANDLERDATA->m_ok = TRUE;
 844       DeleteDC(dc);
 845
 846       return TRUE;
 847     }
 848     else
 849     {
 850       M_BITMAPHANDLERDATA->m_ok = FALSE;
 851 //    XpmDebugError(ErrorStatus, NULL);
 852       DeleteDC(dc);
 853       return FALSE;
 854     }
 855   }
 856 #endif
 857
 858   return FALSE;
 859 }
 860
 861 void wxBitmap::CleanUpHandlers(void)
 862 {
 863   wxNode *node = sm_handlers.First();
 864   while ( node )
 865   {
 866     wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
 867     wxNode *next = node->Next();
 868     delete handler;
 869     delete node;
 870     node = next;
 871   }
 872 }
 873
 874 void wxBitmap::InitStandardHandlers(void)
 875 {
 876   AddHandler(new wxBMPResourceHandler);
 877   AddHandler(new wxBMPFileHandler);
 878   AddHandler(new wxXPMFileHandler);
 879   AddHandler(new wxXPMDataHandler);
 880   AddHandler(new wxICOResourceHandler);
 881   AddHandler(new wxICOFileHandler);
 882 }
 883
 884 static long createDIB(long xSize, long ySize, long bitsPerPixel,
 885                        HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
 886 {
 887    unsigned long   i, headerSize;
 888    LPBITMAPINFO    lpDIBheader = NULL;
 889    LPPALETTEENTRY  lpPe = NULL;
 890
 891
 892    // Allocate space for a DIB header
 893    headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
 894    lpDIBheader = (BITMAPINFO *) malloc(headerSize);
 895    lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
 896
 897    GetPaletteEntries(hPal, 0, 256, lpPe);
 898
 899
 900    memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
 901
 902
 903    // Fill in the static parts of the DIB header
 904    lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 905    lpDIBheader->bmiHeader.biWidth = xSize;
 906    lpDIBheader->bmiHeader.biHeight = ySize;
 907    lpDIBheader->bmiHeader.biPlanes = 1;
 908
 909    // this value must be 1, 4, 8 or 24 so PixelDepth can only be
 910    lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
 911    lpDIBheader->bmiHeader.biCompression = BI_RGB;
 912    lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >>
 913 3;
 914    lpDIBheader->bmiHeader.biClrUsed = 256;
 915
 916
 917    // Initialize the DIB palette
 918    for (i = 0; i < 256; i++) {
 919       lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
 920       lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
 921       lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
 922       lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
 923    }
 924
 925    *lpDIBHeader = lpDIBheader;
 926
 927
 928    return (0);
 929
 930 }
 931
 932
 933
 934 static long freeDIB(LPBITMAPINFO lpDIBHeader)
 935 {
 936
 937    if (lpDIBHeader != NULL) {
 938       free(lpDIBHeader);
 939    }
 940
 941    return (0);
 942 }
 943
 944