src/mac/carbon/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        bitmap.cpp
   3 // Purpose:     wxBitmap
   4 // Author:      AUTHOR
   5 // Modified by:
   6 // Created:     ??/??/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) AUTHOR
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "bitmapbase.h"
  14 #pragma implementation "bitmap.h"
  15 #endif
  16
  17 #include "wx/defs.h"
  18
  19 #include "wx/bitmap.h"
  20 #include "wx/icon.h"
  21 #include "wx/log.h"
  22 #include "wx/image.h"
  23 #include "wx/xpmdecod.h"
  24
  25 #if !USE_SHARED_LIBRARIES
  26 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
  27 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  28 IMPLEMENT_ABSTRACT_CLASS(wxBitmapBase , wxGDIObject )
  29 IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandlerBase, wxObject )
  30 #endif
  31
  32 #ifdef __DARWIN__
  33     #include <ApplicationServices/ApplicationServices.h>
  34 #else
  35     #include <PictUtils.h>
  36 #endif
  37
  38 #include "wx/mac/uma.h"
  39
  40 CTabHandle wxMacCreateColorTable( int numColors )
  41 {
  42         CTabHandle newColors; /* Handle to the new color table */
  43
  44         /* Allocate memory for the color table */
  45         newColors = (CTabHandle)NewHandleClear( sizeof (ColorTable) +
  46         sizeof (ColorSpec) * (numColors - 1) );
  47         if (newColors != nil)
  48         {
  49                 /* Initialize the fields */
  50                 (**newColors).ctSeed = GetCTSeed();
  51                 (**newColors).ctFlags = 0;
  52                 (**newColors).ctSize = numColors - 1;
  53                 /* Initialize the table of colors */
  54         }
  55         return newColors ;
  56 }
  57
  58 void wxMacDestroyColorTable( CTabHandle colors )
  59 {
  60         DisposeHandle( (Handle) colors ) ;
  61 }
  62
  63 void wxMacSetColorTableEntry( CTabHandle newColors , int index , int red , int green ,  int blue )
  64 {
  65         (**newColors).ctTable[index].value = index;
  66         (**newColors).ctTable[index].rgb.red = 0 ;// someRedValue;
  67         (**newColors).ctTable[index].rgb.green = 0 ; // someGreenValue;
  68         (**newColors).ctTable[index].rgb.blue = 0 ; // someBlueValue;
  69 }
  70
  71 GWorldPtr wxMacCreateGWorld( int width , int height , int depth )
  72 {
  73         OSErr err = noErr ;
  74         GWorldPtr port ;
  75         Rect rect = { 0 , 0 , height , width } ;
  76
  77         if ( depth < 0 )
  78         {
  79                 depth = wxDisplayDepth() ;
  80         }
  81
  82         err = NewGWorld( &port , depth , &rect , NULL , NULL , 0 ) ;
  83         if ( err == noErr )
  84         {
  85                 return port ;
  86         }
  87         return NULL ;
  88 }
  89
  90 void wxMacDestroyGWorld( GWorldPtr gw )
  91 {
  92         if ( gw )
  93                 DisposeGWorld( gw ) ;
  94 }
  95
  96 #define kDefaultRes 0x00480000 /* Default resolution is 72 DPI; Fixed type */
  97
  98 OSErr SetupCIconHandlePixMap( CIconHandle icon , short depth , Rect  *bounds , CTabHandle colors )
  99 {
 100     CTabHandle newColors;       /* Color table used for the off-screen PixMap */
 101     Ptr        offBaseAddr;     /* Pointer to the off-screen pixel image */
 102     OSErr      error;           /* Returns error code */
 103     short      bytesPerRow;             /* Number of bytes per row in the PixMap */
 104
 105
 106     error = noErr;
 107     newColors = nil;
 108     offBaseAddr = nil;
 109
 110         bytesPerRow = ((depth * (bounds->right - bounds->left) + 31) / 32) * 4;
 111
 112    /* Clone the clut if indexed color; allocate a dummy clut if direct color*/
 113     if (depth <= 8)
 114         {
 115         newColors = colors;
 116         error = HandToHand((Handle *) &newColors);
 117         }
 118     else
 119         {
 120         newColors = (CTabHandle) NewHandle(sizeof(ColorTable) -
 121                 sizeof(CSpecArray));
 122         error = MemError();
 123         }
 124     if (error == noErr)
 125         {
 126         /* Allocate pixel image; long integer multiplication avoids overflow */
 127         (**icon).iconData = NewHandle((unsigned long) bytesPerRow * (bounds->bottom -
 128                 bounds->top));
 129         if ((**icon).iconData != nil)
 130             {
 131             /* Initialize fields common to indexed and direct PixMaps */
 132             (**icon).iconPMap.baseAddr = 0;  /* Point to image */
 133             (**icon).iconPMap.rowBytes = bytesPerRow | /* MSB set for PixMap */
 134                     0x8000;
 135             (**icon).iconPMap.bounds = *bounds;        /* Use given bounds */
 136             (**icon).iconPMap.pmVersion = 0;           /* No special stuff */
 137             (**icon).iconPMap.packType = 0;            /* Default PICT pack */
 138             (**icon).iconPMap.packSize = 0;            /* Always zero in mem */
 139             (**icon).iconPMap.hRes = kDefaultRes;      /* 72 DPI default res */
 140             (**icon).iconPMap.vRes = kDefaultRes;      /* 72 DPI default res */
 141             (**icon).iconPMap.pixelSize = depth;       /* Set # bits/pixel */
 142
 143             /* Initialize fields specific to indexed and direct PixMaps */
 144             if (depth <= 8)
 145                 {
 146                 /* PixMap is indexed */
 147                 (**icon).iconPMap.pixelType = 0;       /* Indicates indexed */
 148                 (**icon).iconPMap.cmpCount = 1;        /* Have 1 component */
 149                 (**icon).iconPMap.cmpSize = depth;     /* Component size=depth */
 150                 (**icon).iconPMap.pmTable = newColors; /* Handle to CLUT */
 151                 }
 152             else
 153                 {
 154                 /* PixMap is direct */
 155                 (**icon).iconPMap.pixelType = RGBDirect; /* Indicates direct */
 156                 (**icon).iconPMap.cmpCount = 3;          /* Have 3 components */
 157                 if (depth == 16)
 158                     (**icon).iconPMap.cmpSize = 5;       /* 5 bits/component */
 159                 else
 160                     (**icon).iconPMap.cmpSize = 8;       /* 8 bits/component */
 161                 (**newColors).ctSeed = 3 * (**icon).iconPMap.cmpSize;
 162                 (**newColors).ctFlags = 0;
 163                 (**newColors).ctSize = 0;
 164                 (**icon).iconPMap.pmTable = newColors;
 165                 }
 166             }
 167         else
 168             error = MemError();
 169         }
 170     else
 171         newColors = nil;
 172
 173     /* If no errors occured, return a handle to the new off-screen PixMap */
 174     if (error != noErr)
 175         {
 176         if (newColors != nil)
 177             DisposeCTable(newColors);
 178         }
 179
 180     /* Return the error code */
 181     return error;
 182 }
 183
 184 CIconHandle wxMacCreateCIcon(GWorldPtr image , GWorldPtr mask , short dstDepth , short iconSize  )
 185 {
 186         GWorldPtr               saveWorld;
 187         GDHandle                saveHandle;
 188
 189         GetGWorld(&saveWorld,&saveHandle);              // save Graphics env state
 190         SetGWorld(image,nil);
 191
 192     Rect frame = { 0 , 0 , iconSize , iconSize } ;
 193     Rect imageBounds = frame ;
 194         GetPortBounds( image , &imageBounds ) ;
 195
 196     int bwSize = iconSize / 8 * iconSize ;
 197     CIconHandle icon = (CIconHandle) NewHandleClear( sizeof ( CIcon ) + 2 * bwSize) ;
 198     HLock((Handle)icon) ;
 199     SetupCIconHandlePixMap( icon , dstDepth , &frame,GetCTable(dstDepth)) ;
 200     HLock( (**icon).iconData ) ;
 201     (**icon).iconPMap.baseAddr = *(**icon).iconData ;
 202
 203         LockPixels(GetGWorldPixMap(image));
 204
 205         CopyBits(GetPortBitMapForCopyBits(image),
 206                                 (BitMapPtr)&((**icon).iconPMap),
 207                                 &imageBounds,
 208                                 &imageBounds,
 209                                 srcCopy | ditherCopy, nil);
 210
 211
 212         UnlockPixels(GetGWorldPixMap(image));
 213     HUnlock( (**icon).iconData ) ;
 214
 215     (**icon).iconMask.rowBytes = iconSize / 8 ;
 216     (**icon).iconMask.bounds = frame ;
 217
 218     (**icon).iconBMap.rowBytes = iconSize / 8 ;
 219     (**icon).iconBMap.bounds = frame ;
 220     (**icon).iconMask.baseAddr = (char*) &(**icon).iconMaskData ;
 221     (**icon).iconBMap.baseAddr = (char*) &(**icon).iconMaskData + bwSize ;
 222
 223     if ( mask )
 224     {
 225       LockPixels(GetGWorldPixMap(mask) ) ;
 226       CopyBits(GetPortBitMapForCopyBits(mask) ,
 227           &(**icon).iconBMap , &imageBounds , &imageBounds, srcCopy , nil ) ;
 228       CopyBits(GetPortBitMapForCopyBits(mask) ,
 229           &(**icon).iconMask , &imageBounds , &imageBounds, srcCopy , nil ) ;
 230       UnlockPixels(GetGWorldPixMap( mask ) ) ;
 231     }
 232     else
 233     {
 234             LockPixels(GetGWorldPixMap(image));
 235       CopyBits(GetPortBitMapForCopyBits(image) ,
 236           &(**icon).iconBMap , &imageBounds , &imageBounds, srcCopy , nil ) ;
 237       CopyBits(GetPortBitMapForCopyBits(image) ,
 238           &(**icon).iconMask , &imageBounds , &imageBounds, srcCopy , nil ) ;
 239             UnlockPixels(GetGWorldPixMap(image));
 240     }
 241
 242     (**icon).iconMask.baseAddr = NULL ;
 243     (**icon).iconBMap.baseAddr = NULL ;
 244     (**icon).iconPMap.baseAddr = NULL ;
 245     HUnlock((Handle)icon) ;
 246         SetGWorld(saveWorld,saveHandle);
 247
 248         return icon;
 249 }
 250
 251 PicHandle wxMacCreatePict(GWorldPtr wp, GWorldPtr mask)
 252 {
 253   CGrafPtr       origPort ;
 254   GDHandle       origDev ;
 255
 256   PicHandle      pict;
 257
 258   RGBColor       white = { 0xffff ,0xffff , 0xffff } ;
 259   RGBColor       black = { 0x0000 ,0x0000 , 0x0000 } ;
 260
 261   GetGWorld( &origPort , &origDev ) ;
 262
 263   RgnHandle clipRgn = NULL ;
 264
 265   if ( mask )
 266   {
 267     clipRgn = NewRgn() ;
 268     LockPixels( GetGWorldPixMap( mask ) ) ;
 269     BitMapToRegion( clipRgn , (BitMap*) *GetGWorldPixMap( mask ) ) ;
 270     UnlockPixels( GetGWorldPixMap( mask ) ) ;
 271   }
 272
 273   SetGWorld( wp , NULL ) ;
 274   Rect portRect ;
 275   GetPortBounds( wp , &portRect ) ;
 276
 277   pict = OpenPicture(&portRect);
 278   if(pict)
 279   {
 280     RGBForeColor( &black ) ;
 281     RGBBackColor( &white ) ;
 282
 283     LockPixels( GetGWorldPixMap( wp ) ) ;
 284     CopyBits(GetPortBitMapForCopyBits(wp),
 285                 GetPortBitMapForCopyBits(wp),
 286                 &portRect,
 287                 &portRect,
 288                 srcCopy,clipRgn);
 289     UnlockPixels( GetGWorldPixMap( wp ) ) ;
 290     ClosePicture();
 291   }
 292   SetGWorld( origPort , origDev ) ;
 293   return pict;
 294 }
 295
 296 wxBitmapRefData::wxBitmapRefData()
 297 {
 298     m_ok = FALSE;
 299     m_width = 0;
 300     m_height = 0;
 301     m_depth = 0;
 302     m_quality = 0;
 303     m_numColors = 0;
 304     m_bitmapMask = NULL;
 305     m_hBitmap = NULL ;
 306     m_hPict = NULL ;
 307     m_hIcon = NULL ;
 308     m_bitmapType = kMacBitmapTypeUnknownType ;
 309 }
 310
 311 // TODO move this do a public function of Bitmap Ref
 312 static void DisposeBitmapRefData(wxBitmapRefData *data)
 313 {
 314         switch (data->m_bitmapType)
 315         {
 316                 case kMacBitmapTypePict :
 317                         {
 318                                 if ( data->m_hPict )
 319                                 {
 320                                         KillPicture( data->m_hPict ) ;
 321                                         data->m_hPict = NULL ;
 322                                 }
 323                         }
 324                         break ;
 325                 case kMacBitmapTypeGrafWorld :
 326                         {
 327                                 if ( data->m_hBitmap )
 328                                 {
 329                                         wxMacDestroyGWorld( data->m_hBitmap ) ;
 330                                         data->m_hBitmap = NULL ;
 331                                 }
 332                         }
 333                         break ;
 334                 case kMacBitmapTypeIcon :
 335                 if ( data->m_hIcon )
 336                 {
 337                         DisposeCIcon( data->m_hIcon ) ;
 338                         data->m_hIcon = NULL ;
 339                 }
 340
 341                 default :
 342                         // unkown type ?
 343                         break ;
 344         }
 345
 346   if (data->m_bitmapMask)
 347   {
 348     delete data->m_bitmapMask;
 349     data->m_bitmapMask = NULL;
 350   }
 351 }
 352
 353 wxBitmapRefData::~wxBitmapRefData()
 354 {
 355   DisposeBitmapRefData( this ) ;
 356 }
 357
 358 wxList wxBitmapBase::sm_handlers;
 359
 360
 361 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 362 {
 363     Ref(icon) ;
 364     return true;
 365 }
 366
 367 wxBitmap::wxBitmap()
 368 {
 369     m_refData = NULL;
 370
 371     if ( wxTheBitmapList )
 372         wxTheBitmapList->AddBitmap(this);
 373 }
 374
 375 wxBitmap::~wxBitmap()
 376 {
 377     if (wxTheBitmapList)
 378         wxTheBitmapList->DeleteObject(this);
 379 }
 380
 381 wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
 382 {
 383     m_refData = new wxBitmapRefData;
 384
 385     M_BITMAPDATA->m_width = the_width ;
 386     M_BITMAPDATA->m_height = the_height ;
 387     M_BITMAPDATA->m_depth = no_bits ;
 388     M_BITMAPDATA->m_numColors = 0;
 389     if ( no_bits == 1 )
 390     {
 391         M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
 392         M_BITMAPDATA->m_hBitmap = wxMacCreateGWorld( the_width , the_height , no_bits ) ;
 393         M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_hBitmap != NULL ) ;
 394
 395         CGrafPtr        origPort ;
 396         GDHandle        origDevice ;
 397
 398         GetGWorld( &origPort , &origDevice ) ;
 399         SetGWorld( M_BITMAPDATA->m_hBitmap , NULL ) ;
 400         LockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ;
 401
 402         // bits is a char array
 403
 404         unsigned char* linestart = (unsigned char*) bits ;
 405         int linesize = ( the_width / (sizeof(unsigned char) * 8)) ;
 406         if ( the_width % (sizeof(unsigned char) * 8) ) {
 407             linesize += sizeof(unsigned char);
 408         }
 409
 410         RGBColor colors[2] = {
 411             { 0xFFFF , 0xFFFF , 0xFFFF } ,
 412             { 0, 0 , 0 }
 413         } ;
 414
 415         for ( int y = 0 ; y < the_height ; ++y , linestart += linesize )
 416         {
 417             for ( int x = 0 ; x < the_width ; ++x )
 418             {
 419                 int index = x / 8 ;
 420                 int bit = x % 8 ;
 421                 int mask = 1 << bit ;
 422                 if ( linestart[index] & mask )
 423                 {
 424                     SetCPixel( x , y , &colors[1] ) ;
 425                 }
 426                 else
 427                 {
 428                     SetCPixel( x , y , &colors[0] ) ;
 429                 }
 430             }
 431         }
 432         UnlockPixels( GetGWorldPixMap( M_BITMAPDATA->m_hBitmap ) ) ;
 433
 434         SetGWorld( origPort , origDevice ) ;
 435     }
 436     else
 437     {
 438         wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
 439     }
 440
 441     if ( wxTheBitmapList ) {
 442         wxTheBitmapList->AddBitmap(this);
 443     }
 444 }
 445
 446 wxBitmap::wxBitmap(int w, int h, int d)
 447 {
 448     (void)Create(w, h, d);
 449
 450     if ( wxTheBitmapList )
 451         wxTheBitmapList->AddBitmap(this);
 452 }
 453
 454 wxBitmap::wxBitmap(void *data, wxBitmapType type, int width, int height, int depth)
 455 {
 456     (void) Create(data, type, width, height, depth);
 457
 458     if ( wxTheBitmapList )
 459         wxTheBitmapList->AddBitmap(this);
 460 }
 461
 462 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 463 {
 464     LoadFile(filename, type);
 465
 466     if ( wxTheBitmapList )
 467         wxTheBitmapList->AddBitmap(this);
 468 }
 469
 470 bool wxBitmap::CreateFromXpm(const char **bits)
 471 {
 472     wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
 473     wxXPMDecoder decoder;
 474     wxImage img = decoder.ReadData(bits);
 475     wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid bitmap data") )
 476     *this = wxBitmap(img);
 477     if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this);
 478     return TRUE;
 479 }
 480
 481 wxBitmap::wxBitmap(const char **bits)
 482 {
 483     (void) CreateFromXpm(bits);
 484 }
 485
 486 wxBitmap::wxBitmap(char **bits)
 487 {
 488     (void) CreateFromXpm((const char **)bits);
 489 }
 490
 491 wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const
 492 {
 493    wxCHECK_MSG( Ok() &&
 494                 (rect.x >= 0) && (rect.y >= 0) &&
 495                 (rect.x+rect.width <= GetWidth()) &&
 496                 (rect.y+rect.height <= GetHeight()),
 497                 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
 498
 499
 500    wxBitmap ret( rect.width, rect.height, GetDepth() );
 501    wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 502
 503    WXHBITMAP origPort;
 504    GDHandle  origDevice;
 505
 506    GetGWorld( &origPort, &origDevice );
 507
 508    // Update the subbitmaps reference data
 509    wxBitmapRefData *ref = (wxBitmapRefData *)ret.GetRefData();
 510
 511    ref->m_numColors     = M_BITMAPDATA->m_numColors;
 512    ref->m_bitmapPalette = M_BITMAPDATA->m_bitmapPalette;
 513    ref->m_bitmapType    = M_BITMAPDATA->m_bitmapType;
 514
 515    // Copy sub region of this bitmap
 516    if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypePict)
 517    {
 518        printf("GetSubBitmap:  Copy a region of a Pict structure - TODO\n");
 519    }
 520    else if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypeGrafWorld)
 521    {
 522        // Copy mask
 523        if(GetMask())
 524        {
 525            WXHBITMAP submask, mask;
 526            RGBColor  color;
 527
 528            mask = GetMask()->GetMaskBitmap();
 529            submask = wxMacCreateGWorld(rect.width, rect.height, 1);
 530            LockPixels(GetGWorldPixMap(mask));
 531            LockPixels(GetGWorldPixMap(submask));
 532
 533            for(int yy = 0; yy < rect.height; yy++)
 534            {
 535                for(int xx = 0; xx < rect.width; xx++)
 536                {
 537                    SetGWorld(mask, NULL);
 538                    GetCPixel(rect.x + xx, rect.y + yy, &color);
 539                    SetGWorld(submask, NULL);
 540                    SetCPixel(xx,yy, &color);
 541                }
 542            }
 543            UnlockPixels(GetGWorldPixMap(mask));
 544            UnlockPixels(GetGWorldPixMap(submask));
 545            ref->m_bitmapMask = new wxMask;
 546            ref->m_bitmapMask->SetMaskBitmap(submask);
 547        }
 548
 549        // Copy bitmap
 550        if(GetHBITMAP())
 551        {
 552            WXHBITMAP subbitmap, bitmap;
 553            RGBColor  color;
 554
 555            bitmap = GetHBITMAP();
 556            subbitmap = ref->m_hBitmap ;
 557            LockPixels(GetGWorldPixMap(bitmap));
 558            LockPixels(GetGWorldPixMap(subbitmap));
 559
 560            for(int yy = 0; yy < rect.height; yy++)
 561            {
 562                for(int xx = 0; xx < rect.width; xx++)
 563                {
 564                    SetGWorld(bitmap, NULL);
 565                    GetCPixel(rect.x + xx, rect.y + yy, &color);
 566                    SetGWorld(subbitmap, NULL);
 567                    SetCPixel(xx, yy, &color);
 568                }
 569            }
 570            UnlockPixels(GetGWorldPixMap(bitmap));
 571            UnlockPixels(GetGWorldPixMap(subbitmap));
 572        }
 573    }
 574    SetGWorld( origPort, origDevice );
 575
 576    return ret;
 577 }
 578
 579 bool wxBitmap::Create(int w, int h, int d)
 580 {
 581     UnRef();
 582
 583     m_refData = new wxBitmapRefData;
 584
 585     M_BITMAPDATA->m_width = w;
 586     M_BITMAPDATA->m_height = h;
 587     M_BITMAPDATA->m_depth = d;
 588
 589     M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
 590     M_BITMAPDATA->m_hBitmap = wxMacCreateGWorld( w , h , d ) ;
 591     M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_hBitmap != NULL ) ;
 592     return M_BITMAPDATA->m_ok;
 593 }
 594
 595 int wxBitmap::GetBitmapType() const
 596 {
 597    wxCHECK_MSG( Ok(), kMacBitmapTypeUnknownType, wxT("invalid bitmap") );
 598
 599    return M_BITMAPDATA->m_bitmapType;
 600 }
 601
 602 void wxBitmap::SetHBITMAP(WXHBITMAP bmp)
 603 {
 604     DisposeBitmapRefData( M_BITMAPDATA ) ;
 605
 606     M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
 607     M_BITMAPDATA->m_hBitmap = bmp ;
 608           M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_hBitmap != NULL ) ;
 609 }
 610
 611 bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
 612 {
 613     UnRef();
 614
 615     wxBitmapHandler *handler = FindHandler(type);
 616
 617     if ( handler )
 618     {
 619         m_refData = new wxBitmapRefData;
 620
 621         return handler->LoadFile(this, filename, type, -1, -1);
 622     }
 623     else
 624     {
 625         wxImage loadimage(filename, type);
 626         if (loadimage.Ok()) {
 627             *this = loadimage;
 628             return true;
 629         }
 630     }
 631     wxLogWarning("no bitmap handler for type %d defined.", type);
 632     return false;
 633 }
 634
 635 bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)
 636 {
 637     UnRef();
 638
 639     m_refData = new wxBitmapRefData;
 640
 641     wxBitmapHandler *handler = FindHandler(type);
 642
 643     if ( handler == NULL ) {
 644         wxLogWarning("no bitmap handler for type %d defined.", type);
 645
 646         return FALSE;
 647     }
 648
 649     return handler->Create(this, data, type, width, height, depth);
 650 }
 651
 652 wxBitmap::wxBitmap(const wxImage& image, int depth)
 653 {
 654     wxCHECK_RET( image.Ok(), wxT("invalid image") )
 655     wxCHECK_RET( depth == -1, wxT("invalid bitmap depth") )
 656
 657     m_refData = new wxBitmapRefData();
 658
 659     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 660
 661     // width and height of the device-dependent bitmap
 662     int width = image.GetWidth();
 663     int height = image.GetHeight();
 664
 665     // Create picture
 666
 667     Create( width , height , 32 ) ;
 668
 669     CGrafPtr origPort ;
 670     GDHandle origDevice ;
 671
 672     PixMapHandle pixMap = GetGWorldPixMap(GetHBITMAP()) ;
 673     LockPixels( pixMap );
 674
 675     GetGWorld( &origPort , &origDevice ) ;
 676     SetGWorld( GetHBITMAP() , NULL ) ;
 677
 678     // Render image
 679     RGBColor colorRGB ;
 680
 681     register unsigned char* data = image.GetData();
 682     char* destinationBase = GetPixBaseAddr( pixMap );
 683     register unsigned char* destination = (unsigned char*) destinationBase ;
 684     for (int y = 0; y < height; y++)
 685     {
 686         for (int x = 0; x < width; x++)
 687         {
 688             *destination++ = 0 ;
 689             *destination++ = *data++ ;
 690             *destination++ = *data++ ;
 691             *destination++ = *data++ ;
 692         }
 693         destinationBase += ((**pixMap).rowBytes & 0x7fff);
 694         destination = (unsigned char*) destinationBase ;
 695     }
 696     if ( image.HasMask() )
 697     {
 698       data = image.GetData();
 699
 700       wxColour maskcolor(image.GetMaskRed(), image.GetMaskGreen(), image.GetMaskBlue());
 701       RGBColor white = { 0xffff, 0xffff, 0xffff };
 702       RGBColor black = { 0     , 0     , 0      };
 703       wxBitmap maskBitmap ;
 704
 705       maskBitmap.Create( width, height, 1);
 706       LockPixels( GetGWorldPixMap(maskBitmap.GetHBITMAP()) );
 707       SetGWorld(maskBitmap.GetHBITMAP(), NULL);
 708
 709       for (int y = 0; y < height; y++)
 710       {
 711           for (int x = 0; x < width; x++)
 712           {
 713               if ( data[0] == image.GetMaskRed() && data[1] == image.GetMaskGreen() && data[2] == image.GetMaskBlue() )
 714               {
 715                 SetCPixel(x,y, &white);
 716               }
 717               else {
 718                       SetCPixel(x,y, &black);
 719               }
 720               data += 3 ;
 721           }
 722       }  // for height
 723       SetGWorld(GetHBITMAP(), NULL);
 724       SetMask(new wxMask( maskBitmap ));
 725       UnlockPixels( GetGWorldPixMap(maskBitmap.GetHBITMAP()) );
 726     }
 727
 728     UnlockPixels( GetGWorldPixMap(GetHBITMAP()) );
 729     SetGWorld( origPort, origDevice );
 730 }
 731
 732 wxImage wxBitmap::ConvertToImage() const
 733 {
 734     wxImage image;
 735
 736     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 737
 738     // create an wxImage object
 739     int width = GetWidth();
 740     int height = GetHeight();
 741     image.Create( width, height );
 742
 743     unsigned char *data = image.GetData();
 744
 745     wxCHECK_MSG( data, wxNullImage, wxT("Could not allocate data for image") );
 746
 747     WXHBITMAP origPort;
 748     GDHandle  origDevice;
 749     int      index;
 750     RGBColor color;
 751     // background color set to RGB(16,16,16) in consistent with wxGTK
 752     unsigned char mask_r=16, mask_g=16, mask_b=16;
 753     SInt16   r,g,b;
 754     wxMask  *mask = GetMask();
 755
 756     GetGWorld( &origPort, &origDevice );
 757     LockPixels(GetGWorldPixMap(GetHBITMAP()));
 758     SetGWorld( GetHBITMAP(), NULL);
 759
 760     // Copy data into image
 761     index = 0;
 762     for (int yy = 0; yy < height; yy++)
 763     {
 764         for (int xx = 0; xx < width; xx++)
 765         {
 766             GetCPixel(xx,yy, &color);
 767             r = ((color.red ) >> 8);
 768             g = ((color.green ) >> 8);
 769             b = ((color.blue ) >> 8);
 770             data[index    ] = r;
 771             data[index + 1] = g;
 772             data[index + 2] = b;
 773             if (mask)
 774             {
 775                 if (mask->PointMasked(xx,yy))
 776                 {
 777                     data[index    ] = mask_r;
 778                     data[index + 1] = mask_g;
 779                     data[index + 2] = mask_b;
 780                 }
 781             }
 782             index += 3;
 783         }
 784     }
 785     if (mask)
 786     {
 787         image.SetMaskColour( mask_r, mask_g, mask_b );
 788         image.SetMask( true );
 789     }
 790
 791     // Free resources
 792     UnlockPixels(GetGWorldPixMap(GetHBITMAP()));
 793     SetGWorld(origPort, origDevice);
 794
 795     return image;
 796 }
 797
 798
 799 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type,
 800                         const wxPalette *palette) const
 801 {
 802     wxBitmapHandler *handler = FindHandler(type);
 803
 804     if ( handler )
 805     {
 806         return handler->SaveFile(this, filename, type, palette);
 807     }
 808     else
 809     {
 810         wxImage image = ConvertToImage();
 811
 812         return image.SaveFile(filename, type);
 813     }
 814
 815     wxLogWarning("no bitmap handler for type %d defined.", type);
 816     return false;
 817 }
 818
 819 bool wxBitmap::Ok() const
 820 {
 821    return (M_BITMAPDATA && M_BITMAPDATA->m_ok);
 822 }
 823
 824 int wxBitmap::GetHeight() const
 825 {
 826    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 827
 828    return M_BITMAPDATA->m_height;
 829 }
 830
 831 int wxBitmap::GetWidth() const
 832 {
 833    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 834
 835    return M_BITMAPDATA->m_width;
 836 }
 837
 838 int wxBitmap::GetDepth() const
 839 {
 840    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 841
 842    return M_BITMAPDATA->m_depth;
 843 }
 844
 845 int wxBitmap::GetQuality() const
 846 {
 847    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 848
 849    return M_BITMAPDATA->m_quality;
 850 }
 851
 852 wxMask *wxBitmap::GetMask() const
 853 {
 854    wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
 855
 856    return M_BITMAPDATA->m_bitmapMask;
 857 }
 858
 859 void wxBitmap::SetWidth(int w)
 860 {
 861     if (!M_BITMAPDATA)
 862         m_refData = new wxBitmapRefData;
 863
 864     M_BITMAPDATA->m_width = w;
 865 }
 866
 867 void wxBitmap::SetHeight(int h)
 868 {
 869     if (!M_BITMAPDATA)
 870         m_refData = new wxBitmapRefData;
 871
 872     M_BITMAPDATA->m_height = h;
 873 }
 874
 875 void wxBitmap::SetDepth(int d)
 876 {
 877     if (!M_BITMAPDATA)
 878         m_refData = new wxBitmapRefData;
 879
 880     M_BITMAPDATA->m_depth = d;
 881 }
 882
 883 void wxBitmap::SetQuality(int q)
 884 {
 885     if (!M_BITMAPDATA)
 886         m_refData = new wxBitmapRefData;
 887
 888     M_BITMAPDATA->m_quality = q;
 889 }
 890
 891 void wxBitmap::SetOk(bool isOk)
 892 {
 893     if (!M_BITMAPDATA)
 894         m_refData = new wxBitmapRefData;
 895
 896     M_BITMAPDATA->m_ok = isOk;
 897 }
 898
 899 wxPalette *wxBitmap::GetPalette() const
 900 {
 901    wxCHECK_MSG( Ok(), NULL, wxT("Invalid bitmap  GetPalette()") );
 902
 903    return &M_BITMAPDATA->m_bitmapPalette;
 904 }
 905
 906 void wxBitmap::SetPalette(const wxPalette& palette)
 907 {
 908     if (!M_BITMAPDATA)
 909         m_refData = new wxBitmapRefData;
 910
 911     M_BITMAPDATA->m_bitmapPalette = palette ;
 912 }
 913
 914 void wxBitmap::SetMask(wxMask *mask)
 915 {
 916     if (!M_BITMAPDATA)
 917         m_refData = new wxBitmapRefData;
 918
 919     // Remove existing mask if there is one.
 920     if (M_BITMAPDATA->m_bitmapMask)
 921         delete M_BITMAPDATA->m_bitmapMask;
 922
 923     M_BITMAPDATA->m_bitmapMask = mask ;
 924 }
 925
 926 WXHBITMAP wxBitmap::GetHBITMAP() const
 927 {
 928    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 929
 930    return M_BITMAPDATA->m_hBitmap;
 931 }
 932
 933 PicHandle wxBitmap::GetPict() const
 934 {
 935    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 936
 937    PicHandle picture;       // This is the returned picture
 938
 939    // If bitmap already in Pict format return pointer
 940    if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypePict) {
 941        return M_BITMAPDATA->m_hPict;
 942    }
 943    else if(M_BITMAPDATA->m_bitmapType != kMacBitmapTypeGrafWorld) {
 944        // Invalid bitmap
 945        return NULL;
 946    }
 947
 948    RGBColor  gray = { 0xCCCC ,0xCCCC , 0xCCCC } ;
 949    RGBColor  white = { 0xffff ,0xffff , 0xffff } ;
 950    RGBColor  black = { 0x0000 ,0x0000 , 0x0000 } ;
 951    CGrafPtr  origPort;
 952    GDHandle  origDev ;
 953    wxMask   *mask;
 954    Rect      portRect ;
 955
 956    GetPortBounds( GetHBITMAP() , &portRect ) ;
 957    int width = portRect.right - portRect.left ;
 958    int height = portRect.bottom - portRect.top ;
 959
 960    LockPixels( GetGWorldPixMap( GetHBITMAP() ) ) ;
 961    GetGWorld( &origPort , &origDev ) ;
 962
 963    mask = GetMask();
 964
 965    SetGWorld( GetHBITMAP() , NULL ) ;
 966
 967    picture = OpenPicture(&portRect);   // open a picture, this disables drawing
 968    if(!picture) {
 969        return NULL;
 970    }
 971
 972    if( mask )
 973    {
 974 #ifdef __DARWIN__
 975        RGBColor trans = white;
 976 #else
 977        RGBBackColor( &gray );
 978        EraseRect( &portRect );
 979        RGBColor trans = gray;
 980 #endif
 981        RGBForeColor( &black ) ;
 982        RGBBackColor( &white ) ;
 983        PenMode(transparent);
 984
 985        for ( int y = 0 ; y < height ; ++y )
 986        {
 987            for( int x = 0 ; x < width ; ++x )
 988            {
 989                if ( !mask->PointMasked(x,y) )
 990                {
 991                    RGBColor col ;
 992
 993                    GetCPixel( x + portRect.left , y + portRect.top , &col ) ;
 994                    SetCPixel( x + portRect.left , y + portRect.top , &col ) ;
 995                }
 996                else {
 997                    // With transparency this sets a blank pixel
 998                    SetCPixel( x + portRect.left , y + portRect.top , &trans);
 999                }
1000            }
1001        }
1002    }
1003    else
1004    {
1005        RGBBackColor( &gray ) ;
1006        EraseRect(&portRect);
1007        RGBForeColor( &black ) ;
1008        RGBBackColor( &white ) ;
1009
1010        CopyBits(GetPortBitMapForCopyBits(GetHBITMAP()),
1011                 // src PixMap - we copy image over itself -
1012                 GetPortBitMapForCopyBits(GetHBITMAP()),
1013                 //  dst PixMap - no drawing occurs
1014                 &portRect,    // srcRect - it will be recorded and compressed -
1015                 &portRect,    // dstRect - into the picture that is open -
1016                 srcCopy,NULL); // copyMode and no clip region
1017    }
1018    ClosePicture();                  // We are done recording the picture
1019    UnlockPixels( GetGWorldPixMap( GetHBITMAP() ) ) ;
1020    SetGWorld( origPort , origDev ) ;
1021
1022    return picture;                  // return our groovy pict handle
1023 }
1024
1025 void wxBitmap::AddHandler(wxBitmapHandler *handler)
1026 {
1027     sm_handlers.Append(handler);
1028 }
1029
1030 void wxBitmap::InsertHandler(wxBitmapHandler *handler)
1031 {
1032     sm_handlers.Insert(handler);
1033 }
1034
1035 bool wxBitmap::RemoveHandler(const wxString& name)
1036 {
1037     wxBitmapHandler *handler = FindHandler(name);
1038     if ( handler )
1039     {
1040         sm_handlers.DeleteObject(handler);
1041         return TRUE;
1042     }
1043     else
1044         return FALSE;
1045 }
1046
1047 wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
1048 {
1049     wxNode *node = sm_handlers.First();
1050     while ( node )
1051     {
1052         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
1053         if ( handler->GetName() == name )
1054             return handler;
1055         node = node->Next();
1056     }
1057     return NULL;
1058 }
1059
1060 wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, wxBitmapType type)
1061 {
1062     wxNode *node = sm_handlers.First();
1063     while ( node )
1064     {
1065         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
1066         if ( handler->GetExtension() == extension &&
1067                     (type == -1 || handler->GetType() == type) )
1068             return handler;
1069         node = node->Next();
1070     }
1071     return NULL;
1072 }
1073
1074 wxBitmapHandler *wxBitmap::FindHandler(wxBitmapType type)
1075 {
1076     wxNode *node = sm_handlers.First();
1077     while ( node )
1078     {
1079         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
1080         if (handler->GetType() == type)
1081             return handler;
1082         node = node->Next();
1083     }
1084     return NULL;
1085 }
1086
1087 /*
1088  * wxMask
1089  */
1090
1091 wxMask::wxMask()
1092 {
1093     m_maskBitmap = 0;
1094 }
1095
1096 // Construct a mask from a bitmap and a colour indicating
1097 // the transparent area
1098 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
1099 {
1100     m_maskBitmap = 0;
1101     Create(bitmap, colour);
1102 }
1103
1104 // Construct a mask from a bitmap and a palette index indicating
1105 // the transparent area
1106 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
1107 {
1108     m_maskBitmap = 0;
1109     Create(bitmap, paletteIndex);
1110 }
1111
1112 // Construct a mask from a mono bitmap (copies the bitmap).
1113 wxMask::wxMask(const wxBitmap& bitmap)
1114 {
1115     m_maskBitmap = 0;
1116     Create(bitmap);
1117 }
1118
1119 wxMask::~wxMask()
1120 {
1121         if ( m_maskBitmap )
1122         {
1123                 wxMacDestroyGWorld( m_maskBitmap ) ;
1124                 m_maskBitmap = NULL ;
1125         }
1126 }
1127
1128 // Create a mask from a mono bitmap (copies the bitmap).
1129 bool wxMask::Create(const wxBitmap& bitmap)
1130 {
1131    if ( m_maskBitmap )
1132    {
1133        wxMacDestroyGWorld( m_maskBitmap ) ;
1134        m_maskBitmap = NULL ;
1135    }
1136    wxCHECK_MSG( bitmap.GetBitmapType() == kMacBitmapTypeGrafWorld, false,
1137                 wxT("Cannot create mask from this bitmap type (TODO)"));
1138    // other types would require a temporary bitmap. not yet implemented
1139
1140    wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap"));
1141
1142    wxCHECK_MSG(bitmap.GetDepth() == 1, false,
1143                wxT("Cannot create mask from colour bitmap"));
1144
1145    m_maskBitmap = wxMacCreateGWorld(bitmap.GetWidth(), bitmap.GetHeight(), 1);
1146    Rect rect = { 0,0, bitmap.GetHeight(), bitmap.GetWidth() };
1147
1148    LockPixels( GetGWorldPixMap(m_maskBitmap) );
1149    LockPixels( GetGWorldPixMap(bitmap.GetHBITMAP()) );
1150    CopyBits(GetPortBitMapForCopyBits(bitmap.GetHBITMAP()),
1151             GetPortBitMapForCopyBits(m_maskBitmap),
1152             &rect, &rect, srcCopy, 0);
1153    UnlockPixels( GetGWorldPixMap(m_maskBitmap) );
1154    UnlockPixels( GetGWorldPixMap(bitmap.GetHBITMAP()) );
1155
1156    return FALSE;
1157 }
1158
1159 // Create a mask from a bitmap and a palette index indicating
1160 // the transparent area
1161 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
1162 {
1163 // TODO
1164     wxCHECK_MSG( 0, false, wxT("Not implemented"));
1165     return FALSE;
1166 }
1167
1168 // Create a mask from a bitmap and a colour indicating
1169 // the transparent area
1170 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
1171 {
1172         if ( m_maskBitmap )
1173         {
1174                 wxMacDestroyGWorld( m_maskBitmap ) ;
1175                 m_maskBitmap = NULL ;
1176         }
1177         wxCHECK_MSG( bitmap.GetBitmapType() == kMacBitmapTypeGrafWorld, false,
1178                  wxT("Cannot create mask from this bitmap type (TODO)"));
1179         // other types would require a temporary bitmap. not yet implemented
1180
1181     wxCHECK_MSG( bitmap.Ok(), false, wxT("Illigal bitmap"));
1182
1183         m_maskBitmap = wxMacCreateGWorld( bitmap.GetWidth() , bitmap.GetHeight() , 1 );
1184         LockPixels( GetGWorldPixMap( m_maskBitmap ) );
1185         LockPixels( GetGWorldPixMap( bitmap.GetHBITMAP() ) );
1186         RGBColor maskColor = colour.GetPixel();
1187
1188     // this is not very efficient, but I can't think
1189     // of a better way of doing it
1190         CGrafPtr        origPort ;
1191         GDHandle        origDevice ;
1192     RGBColor  col;
1193     RGBColor  colors[2] = {
1194         { 0xFFFF, 0xFFFF, 0xFFFF },
1195         { 0,      0,      0 }};
1196
1197         GetGWorld( &origPort , &origDevice ) ;
1198         for (int w = 0; w < bitmap.GetWidth(); w++)
1199     {
1200         for (int h = 0; h < bitmap.GetHeight(); h++)
1201         {
1202                         SetGWorld( bitmap.GetHBITMAP(), NULL ) ;
1203                         GetCPixel( w , h , &col ) ;
1204                         SetGWorld( m_maskBitmap , NULL ) ;
1205             if (col.red == maskColor.red && col.green == maskColor.green && col.blue == maskColor.blue)
1206             {
1207                                 SetCPixel( w , h , &colors[0] ) ;
1208             }
1209             else
1210             {
1211                                 SetCPixel( w , h , &colors[1] ) ;
1212             }
1213         }
1214     }
1215         UnlockPixels( GetGWorldPixMap( (CGrafPtr) m_maskBitmap ) ) ;
1216         UnlockPixels( GetGWorldPixMap( bitmap.GetHBITMAP() ) ) ;
1217         SetGWorld( origPort , origDevice ) ;
1218
1219     return TRUE;
1220 }
1221
1222 bool wxMask::PointMasked(int x, int y)
1223 {
1224    WXHBITMAP origPort;
1225    GDHandle  origDevice;
1226    RGBColor  color;
1227    bool masked = true;
1228
1229    GetGWorld( &origPort, &origDevice);
1230
1231    //Set port to mask and see if it masked (1) or not ( 0 )
1232    SetGWorld(m_maskBitmap, NULL);
1233    LockPixels(GetGWorldPixMap(m_maskBitmap));
1234    GetCPixel(x,y, &color);
1235    masked = !(color.red == 0 && color.green == 0 && color.blue == 0);
1236    UnlockPixels(GetGWorldPixMap(m_maskBitmap));
1237
1238    SetGWorld( origPort, origDevice);
1239
1240    return masked;
1241 }
1242
1243 /*
1244  * wxBitmapHandler
1245  */
1246
1247 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
1248
1249 bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
1250 {
1251     return FALSE;
1252 }
1253
1254 bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1255         int desiredWidth, int desiredHeight)
1256 {
1257     return FALSE;
1258 }
1259
1260 bool wxBitmapHandler::SaveFile(const wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
1261 {
1262     return FALSE;
1263 }
1264
1265 /*
1266  * Standard handlers
1267  */
1268
1269 class WXDLLEXPORT wxPICTResourceHandler: public wxBitmapHandler
1270 {
1271     DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler)
1272 public:
1273     inline wxPICTResourceHandler()
1274     {
1275         m_name = "Macintosh Pict resource";
1276         m_extension = "";
1277         m_type = wxBITMAP_TYPE_PICT_RESOURCE;
1278     };
1279
1280     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1281           int desiredWidth, int desiredHeight);
1282 };
1283 IMPLEMENT_DYNAMIC_CLASS(wxPICTResourceHandler, wxBitmapHandler)
1284
1285 bool  wxPICTResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1286           int desiredWidth, int desiredHeight)
1287 {
1288         Str255 theName ;
1289
1290 #if TARGET_CARBON
1291         c2pstrcpy( (StringPtr) theName , name ) ;
1292 #else
1293         strcpy( (char *) theName , name ) ;
1294         c2pstr( (char *)theName ) ;
1295 #endif
1296
1297         PicHandle thePict = (PicHandle ) GetNamedResource( 'PICT' , theName ) ;
1298         if ( thePict )
1299         {
1300                 PictInfo theInfo ;
1301
1302                 GetPictInfo( thePict , &theInfo , 0 , 0 , systemMethod , 0 ) ;
1303                 DetachResource( (Handle) thePict ) ;
1304                 M_BITMAPHANDLERDATA->m_bitmapType = kMacBitmapTypePict ;
1305                 M_BITMAPHANDLERDATA->m_hPict = thePict ;
1306                 M_BITMAPHANDLERDATA->m_width =  theInfo.sourceRect.right - theInfo.sourceRect.left ;
1307                 M_BITMAPHANDLERDATA->m_height = theInfo.sourceRect.bottom - theInfo.sourceRect.top ;
1308
1309                 M_BITMAPHANDLERDATA->m_depth = theInfo.depth ;
1310                 M_BITMAPHANDLERDATA->m_ok = true ;
1311                 M_BITMAPHANDLERDATA->m_numColors = theInfo.uniqueColors ;
1312 //              M_BITMAPHANDLERDATA->m_bitmapPalette;
1313 //              M_BITMAPHANDLERDATA->m_quality;
1314                 return TRUE ;
1315         }
1316         return FALSE ;
1317 }
1318
1319 #if 0   // The following is an example for creating a bitmap handler
1320
1321 // TODO: bitmap handlers, a bit like this:
1322 class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
1323 {
1324     DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
1325 public:
1326     inline wxBMPResourceHandler()
1327     {
1328         m_name = "Windows bitmap resource";
1329         m_extension = "";
1330         m_type = wxBITMAP_TYPE_BMP_RESOURCE;
1331     };
1332
1333     virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1334           int desiredWidth, int desiredHeight);
1335 };
1336 IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
1337
1338 #endif
1339
1340 void wxBitmap::CleanUpHandlers()
1341 {
1342     wxNode *node = sm_handlers.First();
1343     while ( node )
1344     {
1345         wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
1346         wxNode *next = node->Next();
1347         delete handler;
1348         delete node;
1349         node = next;
1350     }
1351 }
1352
1353 void wxBitmap::InitStandardHandlers()
1354 {
1355     AddHandler(new wxPICTResourceHandler) ;
1356     AddHandler(new wxICONResourceHandler) ;
1357 }