src/mac/classic/bitmap.cpp

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