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