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