src/mac/carbon/bitmap.cpp

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