]> git.saurik.com Git - wxWidgets.git/blob - src/mac/bitmap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
correct boundaries for carbon
[wxWidgets.git] / src / mac / 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 ref->m_bitmapPalette = M_BITMAPDATA->m_bitmapPalette;
555 ref->m_bitmapType = M_BITMAPDATA->m_bitmapType;
556
557 // Copy sub region of this bitmap
558 if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypePict)
559 {
560 printf("GetSubBitmap: Copy a region of a Pict structure - TODO\n");
561 }
562 else if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypeGrafWorld)
563 {
564 // Copy mask
565 if(GetMask())
566 {
567 GWorldPtr submask, mask;
568 RGBColor color;
569
570 mask = (GWorldPtr) GetMask()->GetMaskBitmap();
571 submask = wxMacCreateGWorld(rect.width, rect.height, GetMask()->GetDepth() );
572 LockPixels(GetGWorldPixMap(mask));
573 LockPixels(GetGWorldPixMap(submask));
574
575 for(int yy = 0; yy < rect.height; yy++)
576 {
577 for(int xx = 0; xx < rect.width; xx++)
578 {
579 SetGWorld(mask, NULL);
580 GetCPixel(rect.x + xx, rect.y + yy, &color);
581 SetGWorld(submask, NULL);
582 SetCPixel(xx,yy, &color);
583 }
584 }
585 UnlockPixels(GetGWorldPixMap(mask));
586 UnlockPixels(GetGWorldPixMap(submask));
587 ref->m_bitmapMask = new wxMask;
588 ref->m_bitmapMask->SetMaskBitmap(submask);
589 }
590
591 // Copy bitmap
592 if(GetHBITMAP())
593 {
594 GWorldPtr subbitmap, bitmap;
595 RGBColor color;
596
597 bitmap = (GWorldPtr) GetHBITMAP();
598 subbitmap = (GWorldPtr) ref->m_hBitmap ;
599 LockPixels(GetGWorldPixMap(bitmap));
600 LockPixels(GetGWorldPixMap(subbitmap));
601
602 for(int yy = 0; yy < rect.height; yy++)
603 {
604 for(int xx = 0; xx < rect.width; xx++)
605 {
606 SetGWorld(bitmap, NULL);
607 GetCPixel(rect.x + xx, rect.y + yy, &color);
608 SetGWorld(subbitmap, NULL);
609 SetCPixel(xx, yy, &color);
610 }
611 }
612 UnlockPixels(GetGWorldPixMap(bitmap));
613 UnlockPixels(GetGWorldPixMap(subbitmap));
614 }
615 }
616 SetGWorld( origPort, origDevice );
617
618 return ret;
619 }
620
621 bool wxBitmap::Create(int w, int h, int d)
622 {
623 UnRef();
624
625 m_refData = new wxBitmapRefData;
626
627 M_BITMAPDATA->m_width = w;
628 M_BITMAPDATA->m_height = h;
629 M_BITMAPDATA->m_depth = d;
630
631 M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
632 M_BITMAPDATA->m_hBitmap = wxMacCreateGWorld( w , h , d ) ;
633 M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hBitmap != NULL ) ;
634 return M_BITMAPDATA->m_ok;
635 }
636
637 int wxBitmap::GetBitmapType() const
638 {
639 wxCHECK_MSG( Ok(), kMacBitmapTypeUnknownType, wxT("invalid bitmap") );
640
641 return M_BITMAPDATA->m_bitmapType;
642 }
643
644 void wxBitmap::SetHBITMAP(WXHBITMAP bmp)
645 {
646 if (!M_BITMAPDATA)
647 m_refData = new wxBitmapRefData;
648 else
649 DisposeBitmapRefData( M_BITMAPDATA ) ;
650
651 M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
652 M_BITMAPDATA->m_hBitmap = bmp ;
653 M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hBitmap != NULL ) ;
654 }
655
656 void wxBitmap::SetHICON(WXHICON ico)
657 {
658 if (!M_BITMAPDATA)
659 m_refData = new wxBitmapRefData;
660 else
661 DisposeBitmapRefData( M_BITMAPDATA ) ;
662
663 M_BITMAPDATA->m_bitmapType = kMacBitmapTypeIcon ;
664 M_BITMAPDATA->m_hIcon = ico ;
665 M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hIcon != NULL ) ;
666 }
667
668 void wxBitmap::SetPict(WXHMETAFILE pict)
669 {
670 if (!M_BITMAPDATA)
671 m_refData = new wxBitmapRefData;
672 else
673 DisposeBitmapRefData( M_BITMAPDATA ) ;
674
675 M_BITMAPDATA->m_bitmapType = kMacBitmapTypePict ;
676 M_BITMAPDATA->m_hPict = pict ;
677 M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hPict != NULL ) ;
678 }
679
680 bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
681 {
682 UnRef();
683
684 wxBitmapHandler *handler = FindHandler(type);
685
686 if ( handler )
687 {
688 m_refData = new wxBitmapRefData;
689
690 return handler->LoadFile(this, filename, type, -1, -1);
691 }
692 else
693 {
694 wxImage loadimage(filename, type);
695 if (loadimage.Ok()) {
696 *this = loadimage;
697 return true;
698 }
699 }
700 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
701 return false;
702 }
703
704 bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)
705 {
706 UnRef();
707
708 m_refData = new wxBitmapRefData;
709
710 wxBitmapHandler *handler = FindHandler(type);
711
712 if ( handler == NULL ) {
713 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
714
715 return FALSE;
716 }
717
718 return handler->Create(this, data, type, width, height, depth);
719 }
720
721 wxBitmap::wxBitmap(const wxImage& image, int depth)
722 {
723 wxCHECK_RET( image.Ok(), wxT("invalid image") )
724 wxCHECK_RET( depth == -1, wxT("invalid bitmap depth") )
725
726 m_refData = new wxBitmapRefData();
727
728 // width and height of the device-dependent bitmap
729 int width = image.GetWidth();
730 int height = image.GetHeight();
731
732 // Create picture
733
734 Create( width , height , 32 ) ;
735
736 CGrafPtr origPort ;
737 GDHandle origDevice ;
738
739 PixMapHandle pixMap = GetGWorldPixMap((GWorldPtr)GetHBITMAP()) ;
740 LockPixels( pixMap );
741
742 GetGWorld( &origPort , &origDevice ) ;
743 SetGWorld( (GWorldPtr) GetHBITMAP() , NULL ) ;
744
745 // Render image
746 register unsigned char* data = image.GetData();
747 char* destinationBase = GetPixBaseAddr( pixMap );
748 register unsigned char* destination = (unsigned char*) destinationBase ;
749 for (int y = 0; y < height; y++)
750 {
751 for (int x = 0; x < width; x++)
752 {
753 *destination++ = 0 ;
754 *destination++ = *data++ ;
755 *destination++ = *data++ ;
756 *destination++ = *data++ ;
757 }
758 destinationBase += ((**pixMap).rowBytes & 0x7fff);
759 destination = (unsigned char*) destinationBase ;
760 }
761 if ( image.HasAlpha() )
762 {
763 unsigned char *alpha = image.GetAlpha();
764
765 wxColour maskcolor(image.GetMaskRed(), image.GetMaskGreen(), image.GetMaskBlue());
766 RGBColor color ;
767 wxBitmap maskBitmap ;
768
769 maskBitmap.Create( width, height, 24);
770 LockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) );
771 SetGWorld( (GWorldPtr) maskBitmap.GetHBITMAP(), NULL);
772
773 for (int y = 0; y < height; y++)
774 {
775 for (int x = 0; x < width; x++)
776 {
777 memset( &color , 255 - *alpha , sizeof( color ) );
778 SetCPixel(x,y, &color);
779
780 alpha += 1 ;
781 }
782 } // for height
783 SetGWorld( (GWorldPtr) GetHBITMAP(), NULL);
784 SetMask(new wxMask( maskBitmap ));
785 UnlockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) );
786 }
787 else if ( image.HasMask() )
788 {
789 data = image.GetData();
790
791 wxColour maskcolor(image.GetMaskRed(), image.GetMaskGreen(), image.GetMaskBlue());
792 RGBColor white = { 0xffff, 0xffff, 0xffff };
793 RGBColor black = { 0 , 0 , 0 };
794 wxBitmap maskBitmap ;
795
796 maskBitmap.Create( width, height, 1);
797 LockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) );
798 SetGWorld( (GWorldPtr) maskBitmap.GetHBITMAP(), NULL);
799
800 for (int y = 0; y < height; y++)
801 {
802 for (int x = 0; x < width; x++)
803 {
804 if ( data[0] == image.GetMaskRed() && data[1] == image.GetMaskGreen() && data[2] == image.GetMaskBlue() )
805 {
806 SetCPixel(x,y, &white);
807 }
808 else {
809 SetCPixel(x,y, &black);
810 }
811 data += 3 ;
812 }
813 } // for height
814 SetGWorld( (GWorldPtr) GetHBITMAP(), NULL);
815 SetMask(new wxMask( maskBitmap ));
816 UnlockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) );
817 }
818
819 UnlockPixels( GetGWorldPixMap( (GWorldPtr) GetHBITMAP()) );
820 SetGWorld( origPort, origDevice );
821 }
822
823 wxImage wxBitmap::ConvertToImage() const
824 {
825 wxImage image;
826
827 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
828
829 // create an wxImage object
830 int width = GetWidth();
831 int height = GetHeight();
832 image.Create( width, height );
833
834 unsigned char *data = image.GetData();
835
836 wxCHECK_MSG( data, wxNullImage, wxT("Could not allocate data for image") );
837
838 GWorldPtr origPort;
839 GDHandle origDevice;
840 RgnHandle maskRgn = NULL ;
841 GWorldPtr tempPort = NULL ;
842 int index;
843 RGBColor color;
844 // background color set to RGB(16,16,16) in consistent with wxGTK
845 unsigned char mask_r=16, mask_g=16, mask_b=16;
846 SInt16 r,g,b;
847 wxMask *mask = GetMask();
848
849 GetGWorld( &origPort, &origDevice );
850 if ( GetBitmapType() != kMacBitmapTypeGrafWorld )
851 {
852 tempPort = wxMacCreateGWorld( width , height , -1) ;
853 }
854 else
855 {
856 tempPort = (GWorldPtr) GetHBITMAP() ;
857 }
858 LockPixels(GetGWorldPixMap(tempPort));
859 SetGWorld( tempPort, NULL);
860 if ( GetBitmapType() == kMacBitmapTypePict || GetBitmapType() == kMacBitmapTypeIcon )
861 {
862 Rect bitmaprect = { 0 , 0 , height, width };
863 if ( GetBitmapType() == kMacBitmapTypeIcon )
864 {
865 ::PlotCIconHandle( &bitmaprect , atNone , ttNone , MAC_WXHICON(GetHICON()) ) ;
866 maskRgn = NewRgn() ;
867 BitMapToRegion( maskRgn , &(**(MAC_WXHICON(GetHICON()))).iconMask ) ;
868 }
869 else
870 ::DrawPicture( (PicHandle) GetPict(), &bitmaprect ) ;
871 }
872 // Copy data into image
873 index = 0;
874 for (int yy = 0; yy < height; yy++)
875 {
876 for (int xx = 0; xx < width; xx++)
877 {
878 GetCPixel(xx,yy, &color);
879 r = ((color.red ) >> 8);
880 g = ((color.green ) >> 8);
881 b = ((color.blue ) >> 8);
882 data[index ] = r;
883 data[index + 1] = g;
884 data[index + 2] = b;
885 if ( maskRgn )
886 {
887 Point pt ;
888 pt.h = xx ;
889 pt.v = yy ;
890 if ( !PtInRgn( pt , maskRgn ) )
891 {
892 data[index ] = mask_r;
893 data[index + 1] = mask_g;
894 data[index + 2] = mask_b;
895 }
896 }
897 else
898 {
899 if (mask)
900 {
901 if (mask->PointMasked(xx,yy))
902 {
903 data[index ] = mask_r;
904 data[index + 1] = mask_g;
905 data[index + 2] = mask_b;
906 }
907 }
908 }
909 index += 3;
910 }
911 }
912 if (mask || maskRgn )
913 {
914 image.SetMaskColour( mask_r, mask_g, mask_b );
915 image.SetMask( true );
916 }
917
918 // Free resources
919 UnlockPixels(GetGWorldPixMap( tempPort ));
920 SetGWorld(origPort, origDevice);
921 if ( GetBitmapType() != kMacBitmapTypeGrafWorld )
922 {
923 wxMacDestroyGWorld( tempPort ) ;
924 }
925 if ( maskRgn )
926 {
927 DisposeRgn( maskRgn ) ;
928 }
929
930 return image;
931 }
932
933
934 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type,
935 const wxPalette *palette) const
936 {
937 wxBitmapHandler *handler = FindHandler(type);
938
939 if ( handler )
940 {
941 return handler->SaveFile(this, filename, type, palette);
942 }
943 else
944 {
945 wxImage image = ConvertToImage();
946
947 return image.SaveFile(filename, type);
948 }
949
950 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
951 return false;
952 }
953
954 bool wxBitmap::Ok() const
955 {
956 return (M_BITMAPDATA && M_BITMAPDATA->m_ok);
957 }
958
959 int wxBitmap::GetHeight() const
960 {
961 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
962
963 return M_BITMAPDATA->m_height;
964 }
965
966 int wxBitmap::GetWidth() const
967 {
968 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
969
970 return M_BITMAPDATA->m_width;
971 }
972
973 int wxBitmap::GetDepth() const
974 {
975 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
976
977 return M_BITMAPDATA->m_depth;
978 }
979
980 int wxBitmap::GetQuality() const
981 {
982 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
983
984 return M_BITMAPDATA->m_quality;
985 }
986
987 wxMask *wxBitmap::GetMask() const
988 {
989 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
990
991 return M_BITMAPDATA->m_bitmapMask;
992 }
993
994 void wxBitmap::SetWidth(int w)
995 {
996 if (!M_BITMAPDATA)
997 m_refData = new wxBitmapRefData;
998
999 M_BITMAPDATA->m_width = w;
1000 }
1001
1002 void wxBitmap::SetHeight(int h)
1003 {
1004 if (!M_BITMAPDATA)
1005 m_refData = new wxBitmapRefData;
1006
1007 M_BITMAPDATA->m_height = h;
1008 }
1009
1010 void wxBitmap::SetDepth(int d)
1011 {
1012 if (!M_BITMAPDATA)
1013 m_refData = new wxBitmapRefData;
1014
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 wxPalette *wxBitmap::GetPalette() const
1035 {
1036 wxCHECK_MSG( Ok(), NULL, wxT("Invalid bitmap GetPalette()") );
1037
1038 return &M_BITMAPDATA->m_bitmapPalette;
1039 }
1040
1041 void wxBitmap::SetPalette(const wxPalette& palette)
1042 {
1043 if (!M_BITMAPDATA)
1044 m_refData = new wxBitmapRefData;
1045
1046 M_BITMAPDATA->m_bitmapPalette = palette ;
1047 }
1048
1049 void wxBitmap::SetMask(wxMask *mask)
1050 {
1051 if (!M_BITMAPDATA)
1052 m_refData = new wxBitmapRefData;
1053
1054 // Remove existing mask if there is one.
1055 delete M_BITMAPDATA->m_bitmapMask;
1056
1057 M_BITMAPDATA->m_bitmapMask = mask ;
1058 }
1059
1060 WXHBITMAP wxBitmap::GetHBITMAP() const
1061 {
1062 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
1063
1064 return MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap);
1065 }
1066
1067 WXHMETAFILE wxBitmap::GetPict( bool *created ) const
1068 {
1069 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
1070
1071 PicHandle picture = NULL ; // This is the returned picture
1072 if ( created )
1073 (*created) = false ;
1074 // If bitmap already in Pict format return pointer
1075 if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypePict) {
1076 return M_BITMAPDATA->m_hPict;
1077 }
1078 else if(M_BITMAPDATA->m_bitmapType != kMacBitmapTypeGrafWorld) {
1079 // Invalid bitmap
1080 return NULL;
1081 }
1082 else
1083 {
1084 if ( GetMask() )
1085 {
1086 picture = wxMacCreatePict( MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) , MAC_WXHBITMAP(GetMask()->GetMaskBitmap() ) ) ;
1087 }
1088 else
1089 {
1090 picture = wxMacCreatePict( MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) , NULL ) ;
1091 }
1092 if ( created && picture )
1093 (*created) = true ;
1094 }
1095 return picture ;
1096 }
1097
1098 /*
1099 * wxMask
1100 */
1101
1102 wxMask::wxMask()
1103 : m_maskBitmap(NULL)
1104 {
1105 }
1106
1107 // Construct a mask from a bitmap and a colour indicating
1108 // the transparent area
1109 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
1110 : m_maskBitmap(NULL)
1111 {
1112 Create(bitmap, colour);
1113 }
1114
1115 // Construct a mask from a bitmap and a palette index indicating
1116 // the transparent area
1117 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
1118 : m_maskBitmap(NULL)
1119 {
1120 Create(bitmap, paletteIndex);
1121 }
1122
1123 // Construct a mask from a mono bitmap (copies the bitmap).
1124 wxMask::wxMask(const wxBitmap& bitmap)
1125 : m_maskBitmap(NULL)
1126 {
1127 Create(bitmap);
1128 }
1129
1130 wxMask::~wxMask()
1131 {
1132 if ( m_maskBitmap )
1133 {
1134 wxMacDestroyGWorld( (GWorldPtr) m_maskBitmap ) ;
1135 m_maskBitmap = NULL ;
1136 }
1137 }
1138
1139 // Create a mask from a mono bitmap (copies the bitmap).
1140 bool wxMask::Create(const wxBitmap& bitmap)
1141 {
1142 if ( m_maskBitmap )
1143 {
1144 wxMacDestroyGWorld( (GWorldPtr) m_maskBitmap ) ;
1145 m_maskBitmap = NULL ;
1146 }
1147 wxCHECK_MSG( bitmap.GetBitmapType() == kMacBitmapTypeGrafWorld, false,
1148 wxT("Cannot create mask from this bitmap type (TODO)"));
1149 // other types would require a temporary bitmap. not yet implemented
1150
1151 wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap"));
1152
1153 m_depth = bitmap.GetDepth() ;
1154 m_maskBitmap = wxMacCreateGWorld(bitmap.GetWidth(), bitmap.GetHeight(), bitmap.GetDepth() );
1155 Rect rect = { 0,0, bitmap.GetHeight(), bitmap.GetWidth() };
1156
1157 LockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap) );
1158 LockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP()) );
1159 CopyBits(GetPortBitMapForCopyBits( (GWorldPtr) bitmap.GetHBITMAP()),
1160 GetPortBitMapForCopyBits( (GWorldPtr) m_maskBitmap),
1161 &rect, &rect, srcCopy, 0);
1162 UnlockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap) );
1163 UnlockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP()) );
1164
1165 return FALSE;
1166 }
1167
1168 // Create a mask from a bitmap and a palette index indicating
1169 // the transparent area
1170 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
1171 {
1172 // TODO
1173 wxCHECK_MSG( 0, false, wxT("wxMask::Create not yet implemented"));
1174 return FALSE;
1175 }
1176
1177 // Create a mask from a bitmap and a colour indicating
1178 // the transparent area
1179 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
1180 {
1181 if ( m_maskBitmap )
1182 {
1183 wxMacDestroyGWorld( (GWorldPtr) m_maskBitmap ) ;
1184 m_maskBitmap = NULL ;
1185 }
1186 wxCHECK_MSG( bitmap.GetBitmapType() == kMacBitmapTypeGrafWorld, false,
1187 wxT("Cannot create mask from this bitmap type (TODO)"));
1188 // other types would require a temporary bitmap. not yet implemented
1189
1190 wxCHECK_MSG( bitmap.Ok(), false, wxT("Illigal bitmap"));
1191
1192 m_maskBitmap = wxMacCreateGWorld( bitmap.GetWidth() , bitmap.GetHeight() , 1 );
1193 m_depth = 1 ;
1194 LockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap ) );
1195 LockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP() ) );
1196 RGBColor maskColor = MAC_WXCOLORREF(colour.GetPixel());
1197
1198 // this is not very efficient, but I can't think
1199 // of a better way of doing it
1200 CGrafPtr origPort ;
1201 GDHandle origDevice ;
1202 RGBColor col;
1203 RGBColor colors[2] = {
1204 { 0xFFFF, 0xFFFF, 0xFFFF },
1205 { 0, 0, 0 }};
1206
1207 GetGWorld( &origPort , &origDevice ) ;
1208 for (int w = 0; w < bitmap.GetWidth(); w++)
1209 {
1210 for (int h = 0; h < bitmap.GetHeight(); h++)
1211 {
1212 SetGWorld( (GWorldPtr) bitmap.GetHBITMAP(), NULL ) ;
1213 GetCPixel( w , h , &col ) ;
1214 SetGWorld( (GWorldPtr) m_maskBitmap , NULL ) ;
1215 if (col.red == maskColor.red && col.green == maskColor.green && col.blue == maskColor.blue)
1216 {
1217 SetCPixel( w , h , &colors[0] ) ;
1218 }
1219 else
1220 {
1221 SetCPixel( w , h , &colors[1] ) ;
1222 }
1223 }
1224 }
1225 UnlockPixels( GetGWorldPixMap( (CGrafPtr) m_maskBitmap ) ) ;
1226 UnlockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP() ) ) ;
1227 SetGWorld( origPort , origDevice ) ;
1228
1229 return TRUE;
1230 }
1231
1232 bool wxMask::PointMasked(int x, int y)
1233 {
1234 GWorldPtr origPort;
1235 GDHandle origDevice;
1236 RGBColor color;
1237 bool masked = true;
1238
1239 GetGWorld( &origPort, &origDevice);
1240
1241 //Set port to mask and see if it masked (1) or not ( 0 )
1242 SetGWorld( (GWorldPtr) m_maskBitmap, NULL);
1243 LockPixels(GetGWorldPixMap( (GWorldPtr) m_maskBitmap));
1244 GetCPixel(x,y, &color);
1245 masked = !(color.red == 0 && color.green == 0 && color.blue == 0);
1246 UnlockPixels(GetGWorldPixMap( (GWorldPtr) m_maskBitmap));
1247
1248 SetGWorld( origPort, origDevice);
1249
1250 return masked;
1251 }
1252
1253 /*
1254 * wxBitmapHandler
1255 */
1256
1257 wxBitmapHandler::~wxBitmapHandler()
1258 {
1259 }
1260
1261 bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
1262 {
1263 return FALSE;
1264 }
1265
1266 bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1267 int desiredWidth, int desiredHeight)
1268 {
1269 return FALSE;
1270 }
1271
1272 bool wxBitmapHandler::SaveFile(const wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
1273 {
1274 return FALSE;
1275 }
1276
1277 /*
1278 * Standard handlers
1279 */
1280
1281 class WXDLLEXPORT wxPICTResourceHandler: public wxBitmapHandler
1282 {
1283 DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler)
1284 public:
1285 inline wxPICTResourceHandler()
1286 {
1287 m_name = wxT("Macintosh Pict resource");
1288 m_extension = wxEmptyString;
1289 m_type = wxBITMAP_TYPE_PICT_RESOURCE;
1290 };
1291
1292 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1293 int desiredWidth, int desiredHeight);
1294 };
1295 IMPLEMENT_DYNAMIC_CLASS(wxPICTResourceHandler, wxBitmapHandler)
1296
1297 bool wxPICTResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1298 int desiredWidth, int desiredHeight)
1299 {
1300 Str255 theName ;
1301 wxMacStringToPascal( name , theName ) ;
1302
1303 PicHandle thePict = (PicHandle ) GetNamedResource( 'PICT' , theName ) ;
1304 if ( thePict )
1305 {
1306 PictInfo theInfo ;
1307
1308 GetPictInfo( thePict , &theInfo , 0 , 0 , systemMethod , 0 ) ;
1309 DetachResource( (Handle) thePict ) ;
1310 M_BITMAPHANDLERDATA->m_bitmapType = kMacBitmapTypePict ;
1311 M_BITMAPHANDLERDATA->m_hPict = thePict ;
1312 M_BITMAPHANDLERDATA->m_width = theInfo.sourceRect.right - theInfo.sourceRect.left ;
1313 M_BITMAPHANDLERDATA->m_height = theInfo.sourceRect.bottom - theInfo.sourceRect.top ;
1314
1315 M_BITMAPHANDLERDATA->m_depth = theInfo.depth ;
1316 M_BITMAPHANDLERDATA->m_ok = true ;
1317 M_BITMAPHANDLERDATA->m_numColors = theInfo.uniqueColors ;
1318 // M_BITMAPHANDLERDATA->m_bitmapPalette;
1319 // M_BITMAPHANDLERDATA->m_quality;
1320 return TRUE ;
1321 }
1322 return FALSE ;
1323 }
1324
1325 void wxBitmap::InitStandardHandlers()
1326 {
1327 AddHandler(new wxPICTResourceHandler) ;
1328 AddHandler(new wxICONResourceHandler) ;
1329 }
1330
1331 // ----------------------------------------------------------------------------
1332 // raw bitmap access support
1333 // ----------------------------------------------------------------------------
1334
1335 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
1336 {
1337 if ( !Ok() )
1338 {
1339 // no bitmap, no data (raw or otherwise)
1340 return NULL;
1341 }
1342
1343 if ( M_BITMAPDATA->m_bitmapType != kMacBitmapTypeGrafWorld )
1344 {
1345 wxFAIL_MSG( _T("GetRawData() only supported for GWorlds") );
1346
1347 return NULL;
1348 }
1349
1350 GWorldPtr gworld = MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap);
1351 PixMapHandle hPixMap = GetGWorldPixMap(gworld);
1352 wxCHECK_MSG( hPixMap && *hPixMap, NULL,
1353 _T("GetRawData(): failed to get PixMap from GWorld?") );
1354
1355 wxCHECK_MSG( (*hPixMap)->pixelSize == bpp, NULL,
1356 _T("GetRawData(): pixel format mismatch") );
1357
1358 if ( !LockPixels(hPixMap) )
1359 {
1360 wxFAIL_MSG( _T("failed to lock PixMap in GetRawData()") );
1361
1362 return NULL;
1363 }
1364
1365 data.m_width = GetWidth();
1366 data.m_height = GetHeight();
1367 data.m_stride = (*hPixMap)->rowBytes & 0x7fff;
1368
1369 M_BITMAPDATA->m_hasAlpha = false;
1370
1371 return GetPixBaseAddr(hPixMap);
1372 }
1373
1374 void wxBitmap::UngetRawData(wxPixelDataBase& dataBase)
1375 {
1376 if ( !Ok() )
1377 return;
1378
1379 if ( M_BITMAPDATA->m_hasAlpha )
1380 {
1381 wxAlphaPixelData& data = (wxAlphaPixelData&)dataBase;
1382
1383 int w = data.GetWidth(),
1384 h = data.GetHeight();
1385
1386 wxBitmap bmpMask(GetWidth(), GetHeight(), 32);
1387 wxAlphaPixelData dataMask(bmpMask, data.GetOrigin(), wxSize(w, h));
1388 wxAlphaPixelData::Iterator pMask(dataMask),
1389 p(data);
1390 for ( int y = 0; y < h; y++ )
1391 {
1392 wxAlphaPixelData::Iterator rowStartMask = pMask,
1393 rowStart = p;
1394
1395 for ( int x = 0; x < w; x++ )
1396 {
1397 const wxAlphaPixelData::Iterator::ChannelType
1398 alpha = p.Alpha();
1399
1400 pMask.Red() = alpha;
1401 pMask.Green() = alpha;
1402 pMask.Blue() = alpha;
1403
1404 ++p;
1405 ++pMask;
1406 }
1407
1408 p = rowStart;
1409 p.OffsetY(data, 1);
1410
1411 pMask = rowStartMask;
1412 pMask.OffsetY(dataMask, 1);
1413 }
1414
1415 SetMask(new wxMask(bmpMask));
1416 }
1417
1418 GWorldPtr gworld = MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap);
1419 PixMapHandle hPixMap = GetGWorldPixMap(gworld);
1420 if ( hPixMap )
1421 {
1422 UnlockPixels(hPixMap);
1423 }
1424 }
1425
1426 void wxBitmap::UseAlpha()
1427 {
1428 // remember that we are using alpha channel, we'll need to create a proper
1429 // mask in UngetRawData()
1430 M_BITMAPDATA->m_hasAlpha = true;
1431 }
1432
wxWidgets (Impactor)