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