1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/mac/classic/bitmap.cpp
4 // Author: Stefan Csomor
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #include "wx/wxprec.h"
18 #include "wx/bitmap.h"
22 #include "wx/xpmdecod.h"
24 #include "wx/rawbmp.h"
26 IMPLEMENT_DYNAMIC_CLASS(wxBitmap
, wxGDIObject
)
27 IMPLEMENT_DYNAMIC_CLASS(wxMask
, wxObject
)
28 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler
, wxObject
)
31 #include <ApplicationServices/ApplicationServices.h>
33 #include <PictUtils.h>
36 #include "wx/mac/uma.h"
38 CTabHandle
wxMacCreateColorTable( int numColors
)
40 CTabHandle newColors
; /* Handle to the new color table */
42 /* Allocate memory for the color table */
43 newColors
= (CTabHandle
)NewHandleClear( sizeof (ColorTable
) +
44 sizeof (ColorSpec
) * (numColors
- 1) );
47 /* Initialize the fields */
48 (**newColors
).ctSeed
= GetCTSeed();
49 (**newColors
).ctFlags
= 0;
50 (**newColors
).ctSize
= numColors
- 1;
51 /* Initialize the table of colors */
56 void wxMacDestroyColorTable( CTabHandle colors
)
58 DisposeHandle( (Handle
) colors
) ;
61 void wxMacSetColorTableEntry( CTabHandle newColors
, int index
, int red
, int green
, int blue
)
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;
69 GWorldPtr
wxMacCreateGWorld( int width
, int height
, int depth
)
73 Rect rect
= { 0 , 0 , height
, width
} ;
77 depth
= wxDisplayDepth() ;
80 err
= NewGWorld( &port
, depth
, &rect
, NULL
, NULL
, 0 ) ;
88 void wxMacDestroyGWorld( GWorldPtr gw
)
94 #define kDefaultRes 0x00480000 /* Default resolution is 72 DPI; Fixed type */
96 OSErr
SetupCIconHandlePixMap( CIconHandle icon
, short depth
, Rect
*bounds
, CTabHandle colors
)
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 */
108 bytesPerRow
= ((depth
* (bounds
->right
- bounds
->left
) + 31) / 32) * 4;
110 /* Clone the clut if indexed color; allocate a dummy clut if direct color*/
114 error
= HandToHand((Handle
*) &newColors
);
118 newColors
= (CTabHandle
) NewHandle(sizeof(ColorTable
) -
124 /* Allocate pixel image; long integer multiplication avoids overflow */
125 (**icon
).iconData
= NewHandle((unsigned long) bytesPerRow
* (bounds
->bottom
-
127 if ((**icon
).iconData
!= nil
)
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 */
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 */
141 /* Initialize fields specific to indexed and direct PixMaps */
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 */
152 /* PixMap is direct */
153 (**icon
).iconPMap
.pixelType
= RGBDirect
; /* Indicates direct */
154 (**icon
).iconPMap
.cmpCount
= 3; /* Have 3 components */
156 (**icon
).iconPMap
.cmpSize
= 5; /* 5 bits/component */
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
;
171 /* If no errors occurred, return a handle to the new off-screen PixMap */
174 if (newColors
!= nil
)
175 DisposeCTable(newColors
);
178 /* Return the error code */
182 CIconHandle
wxMacCreateCIcon(GWorldPtr image
, GWorldPtr mask
, short dstDepth
, short iconSize
)
187 GetGWorld(&saveWorld
,&saveHandle
); // save Graphics env state
188 SetGWorld(image
,nil
);
190 Rect frame
= { 0 , 0 , iconSize
, iconSize
} ;
191 Rect imageBounds
= frame
;
192 GetPortBounds( image
, &imageBounds
) ;
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
;
201 LockPixels(GetGWorldPixMap(image
));
203 CopyBits(GetPortBitMapForCopyBits(image
),
204 (BitMapPtr
)&((**icon
).iconPMap
),
207 srcCopy
| ditherCopy
, nil
);
210 UnlockPixels(GetGWorldPixMap(image
));
211 HUnlock( (**icon
).iconData
) ;
213 (**icon
).iconMask
.rowBytes
= iconSize
/ 8 ;
214 (**icon
).iconMask
.bounds
= frame
;
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
;
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
) ) ;
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
));
244 (**icon
).iconMask
.baseAddr
= NULL
;
245 (**icon
).iconBMap
.baseAddr
= NULL
;
246 (**icon
).iconPMap
.baseAddr
= NULL
;
247 HUnlock((Handle
)icon
) ;
248 SetGWorld(saveWorld
,saveHandle
);
253 PicHandle
wxMacCreatePict(GWorldPtr wp
, GWorldPtr mask
)
260 RGBColor white
= { 0xffff ,0xffff , 0xffff } ;
261 RGBColor black
= { 0x0000 ,0x0000 , 0x0000 } ;
263 GetGWorld( &origPort
, &origDev
) ;
265 RgnHandle clipRgn
= NULL
;
270 LockPixels( GetGWorldPixMap( mask
) ) ;
271 BitMapToRegion( clipRgn
, (BitMap
*) *GetGWorldPixMap( mask
) ) ;
272 UnlockPixels( GetGWorldPixMap( mask
) ) ;
275 SetGWorld( wp
, NULL
) ;
278 GetRegionBounds( clipRgn
, &portRect
) ;
280 GetPortBounds( wp
, &portRect
) ;
281 pict
= OpenPicture(&portRect
);
284 RGBForeColor( &black
) ;
285 RGBBackColor( &white
) ;
290 LockPixels( GetGWorldPixMap( wp
) ) ;
291 CopyBits(GetPortBitMapForCopyBits(wp
),
292 GetPortBitMapForCopyBits(wp
),
296 UnlockPixels( GetGWorldPixMap( wp
) ) ;
299 SetGWorld( origPort
, origDev
) ;
301 DisposeRgn( clipRgn
) ;
305 void wxMacCreateBitmapButton( ControlButtonContentInfo
*info
, const wxBitmap
& bitmap
, int forceType
)
307 memset( info
, 0 , sizeof(ControlButtonContentInfo
) ) ;
310 wxBitmapRefData
* bmap
= (wxBitmapRefData
*) ( bitmap
.GetRefData()) ;
314 if ( bmap
->m_bitmapType
== kMacBitmapTypePict
)
316 info
->contentType
= kControlContentPictHandle
;
317 info
->u
.picture
= MAC_WXHMETAFILE(bmap
->m_hPict
) ;
319 else if ( bmap
->m_bitmapType
== kMacBitmapTypeGrafWorld
)
321 if ( (forceType
== kControlContentCIconHandle
|| ( bmap
->m_width
== bmap
->m_height
&& forceType
!= kControlContentPictHandle
) ) && ((bmap
->m_width
& 0x3) == 0) )
323 info
->contentType
= kControlContentCIconHandle
;
324 if ( bitmap
.GetMask() )
326 info
->u
.cIconHandle
= wxMacCreateCIcon( MAC_WXHBITMAP(bmap
->m_hBitmap
) , MAC_WXHBITMAP(bitmap
.GetMask()->GetMaskBitmap()) ,
327 8 , bmap
->m_width
) ;
331 info
->u
.cIconHandle
= wxMacCreateCIcon( MAC_WXHBITMAP(bmap
->m_hBitmap
) , NULL
,
332 8 , bmap
->m_width
) ;
337 info
->contentType
= kControlContentPictHandle
;
338 if ( bitmap
.GetMask() )
340 info
->u
.picture
= wxMacCreatePict( MAC_WXHBITMAP(bmap
->m_hBitmap
) , MAC_WXHBITMAP(bitmap
.GetMask()->GetMaskBitmap() ) ) ;
344 info
->u
.picture
= wxMacCreatePict( MAC_WXHBITMAP(bmap
->m_hBitmap
) , NULL
) ;
348 else if ( bmap
->m_bitmapType
== kMacBitmapTypeIcon
)
350 info
->contentType
= kControlContentCIconHandle
;
351 info
->u
.cIconHandle
= MAC_WXHICON(bmap
->m_hIcon
) ;
356 wxBitmapRefData::wxBitmapRefData()
368 m_bitmapType
= kMacBitmapTypeUnknownType
;
372 // TODO move this to a public function of Bitmap Ref
373 static void DisposeBitmapRefData(wxBitmapRefData
*data
)
378 switch (data
->m_bitmapType
)
380 case kMacBitmapTypePict
:
384 KillPicture( MAC_WXHMETAFILE( data
->m_hPict
) ) ;
385 data
->m_hPict
= NULL
;
389 case kMacBitmapTypeGrafWorld
:
391 if ( data
->m_hBitmap
)
393 wxMacDestroyGWorld( MAC_WXHBITMAP(data
->m_hBitmap
) ) ;
394 data
->m_hBitmap
= NULL
;
398 case kMacBitmapTypeIcon
:
401 DisposeCIcon( MAC_WXHICON(data
->m_hIcon
) ) ;
402 data
->m_hIcon
= NULL
;
410 if (data
->m_bitmapMask
)
412 delete data
->m_bitmapMask
;
413 data
->m_bitmapMask
= NULL
;
417 wxBitmapRefData::~wxBitmapRefData()
419 DisposeBitmapRefData( this ) ;
422 bool wxBitmap::CopyFromIcon(const wxIcon
& icon
)
433 wxBitmap::~wxBitmap()
437 wxBitmap::wxBitmap(const char bits
[], int the_width
, int the_height
, int no_bits
)
439 m_refData
= new wxBitmapRefData
;
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;
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
) ;
452 GDHandle origDevice
;
454 GetGWorld( &origPort
, &origDevice
) ;
455 SetGWorld( MAC_WXHBITMAP(M_BITMAPDATA
->m_hBitmap
) , NULL
) ;
456 LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(M_BITMAPDATA
->m_hBitmap
) ) ) ;
458 // bits is a char array
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);
466 RGBColor colors
[2] = {
467 { 0xFFFF , 0xFFFF , 0xFFFF } ,
471 for ( int y
= 0 ; y
< the_height
; ++y
, linestart
+= linesize
)
473 for ( int x
= 0 ; x
< the_width
; ++x
)
477 int mask
= 1 << bit
;
478 if ( linestart
[index
] & mask
)
480 SetCPixel( x
, y
, &colors
[1] ) ;
484 SetCPixel( x
, y
, &colors
[0] ) ;
488 UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(M_BITMAPDATA
->m_hBitmap
) ) ) ;
490 SetGWorld( origPort
, origDevice
) ;
494 wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
498 wxBitmap::wxBitmap(int w
, int h
, int d
)
500 (void)Create(w
, h
, d
);
503 wxBitmap::wxBitmap(void *data
, wxBitmapType type
, int width
, int height
, int depth
)
505 (void) Create(data
, type
, width
, height
, depth
);
508 wxBitmap::wxBitmap(const wxString
& filename
, wxBitmapType type
)
510 LoadFile(filename
, type
);
513 bool wxBitmap::CreateFromXpm(const char **bits
)
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
);
523 wxBitmap::wxBitmap(const char **bits
)
525 (void) CreateFromXpm(bits
);
528 wxBitmap::wxBitmap(char **bits
)
530 (void) CreateFromXpm((const char **)bits
);
533 wxBitmap
wxBitmap::GetSubBitmap(const wxRect
&rect
) const
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") );
542 wxBitmap
ret( rect
.width
, rect
.height
, GetDepth() );
543 wxASSERT_MSG( ret
.Ok(), wxT("GetSubBitmap error") );
548 GetGWorld( &origPort
, &origDevice
);
550 // Update the subbitmaps reference data
551 wxBitmapRefData
*ref
= (wxBitmapRefData
*)ret
.GetRefData();
553 ref
->m_numColors
= M_BITMAPDATA
->m_numColors
;
555 ref
->m_bitmapPalette
= M_BITMAPDATA
->m_bitmapPalette
;
556 #endif // wxUSE_PALETTE
557 ref
->m_bitmapType
= M_BITMAPDATA
->m_bitmapType
;
559 // Copy sub region of this bitmap
560 if(M_BITMAPDATA
->m_bitmapType
== kMacBitmapTypePict
)
562 printf("GetSubBitmap: Copy a region of a Pict structure - TODO\n");
564 else if(M_BITMAPDATA
->m_bitmapType
== kMacBitmapTypeGrafWorld
)
569 GWorldPtr submask
, mask
;
572 mask
= (GWorldPtr
) GetMask()->GetMaskBitmap();
573 submask
= wxMacCreateGWorld(rect
.width
, rect
.height
, GetMask()->GetDepth() );
574 LockPixels(GetGWorldPixMap(mask
));
575 LockPixels(GetGWorldPixMap(submask
));
577 for(int yy
= 0; yy
< rect
.height
; yy
++)
579 for(int xx
= 0; xx
< rect
.width
; xx
++)
581 SetGWorld(mask
, NULL
);
582 GetCPixel(rect
.x
+ xx
, rect
.y
+ yy
, &color
);
583 SetGWorld(submask
, NULL
);
584 SetCPixel(xx
,yy
, &color
);
587 UnlockPixels(GetGWorldPixMap(mask
));
588 UnlockPixels(GetGWorldPixMap(submask
));
589 ref
->m_bitmapMask
= new wxMask
;
590 ref
->m_bitmapMask
->SetMaskBitmap(submask
);
596 GWorldPtr subbitmap
, bitmap
;
599 bitmap
= (GWorldPtr
) GetHBITMAP();
600 subbitmap
= (GWorldPtr
) ref
->m_hBitmap
;
601 LockPixels(GetGWorldPixMap(bitmap
));
602 LockPixels(GetGWorldPixMap(subbitmap
));
604 for(int yy
= 0; yy
< rect
.height
; yy
++)
606 for(int xx
= 0; xx
< rect
.width
; xx
++)
608 SetGWorld(bitmap
, NULL
);
609 GetCPixel(rect
.x
+ xx
, rect
.y
+ yy
, &color
);
610 SetGWorld(subbitmap
, NULL
);
611 SetCPixel(xx
, yy
, &color
);
614 UnlockPixels(GetGWorldPixMap(bitmap
));
615 UnlockPixels(GetGWorldPixMap(subbitmap
));
618 SetGWorld( origPort
, origDevice
);
623 bool wxBitmap::Create(int w
, int h
, int d
)
627 m_refData
= new wxBitmapRefData
;
629 M_BITMAPDATA
->m_width
= w
;
630 M_BITMAPDATA
->m_height
= h
;
631 M_BITMAPDATA
->m_depth
= d
;
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
;
639 int wxBitmap::GetBitmapType() const
641 wxCHECK_MSG( Ok(), kMacBitmapTypeUnknownType
, wxT("invalid bitmap") );
643 return M_BITMAPDATA
->m_bitmapType
;
646 void wxBitmap::SetHBITMAP(WXHBITMAP bmp
)
649 m_refData
= new wxBitmapRefData
;
651 DisposeBitmapRefData( M_BITMAPDATA
) ;
653 M_BITMAPDATA
->m_bitmapType
= kMacBitmapTypeGrafWorld
;
654 M_BITMAPDATA
->m_hBitmap
= bmp
;
655 M_BITMAPDATA
->m_ok
= ( M_BITMAPDATA
->m_hBitmap
!= NULL
) ;
658 void wxBitmap::SetHICON(WXHICON ico
)
661 m_refData
= new wxBitmapRefData
;
663 DisposeBitmapRefData( M_BITMAPDATA
) ;
665 M_BITMAPDATA
->m_bitmapType
= kMacBitmapTypeIcon
;
666 M_BITMAPDATA
->m_hIcon
= ico
;
667 M_BITMAPDATA
->m_ok
= ( M_BITMAPDATA
->m_hIcon
!= NULL
) ;
670 void wxBitmap::SetPict(WXHMETAFILE pict
)
673 m_refData
= new wxBitmapRefData
;
675 DisposeBitmapRefData( M_BITMAPDATA
) ;
677 M_BITMAPDATA
->m_bitmapType
= kMacBitmapTypePict
;
678 M_BITMAPDATA
->m_hPict
= pict
;
679 M_BITMAPDATA
->m_ok
= ( M_BITMAPDATA
->m_hPict
!= NULL
) ;
682 bool wxBitmap::LoadFile(const wxString
& filename
, wxBitmapType type
)
686 wxBitmapHandler
*handler
= FindHandler(type
);
690 m_refData
= new wxBitmapRefData
;
692 return handler
->LoadFile(this, filename
, type
, -1, -1);
696 wxImage
loadimage(filename
, type
);
697 if (loadimage
.Ok()) {
702 wxLogWarning(wxT("no bitmap handler for type %d defined."), type
);
706 bool wxBitmap::Create(void *data
, wxBitmapType type
, int width
, int height
, int depth
)
710 m_refData
= new wxBitmapRefData
;
712 wxBitmapHandler
*handler
= FindHandler(type
);
714 if ( handler
== NULL
) {
715 wxLogWarning(wxT("no bitmap handler for type %d defined."), type
);
720 return handler
->Create(this, data
, type
, width
, height
, depth
);
723 wxBitmap::wxBitmap(const wxImage
& image
, int depth
)
725 wxCHECK_RET( image
.Ok(), wxT("invalid image") );
726 wxCHECK_RET( depth
== -1, wxT("invalid bitmap depth") );
728 m_refData
= new wxBitmapRefData();
730 // width and height of the device-dependent bitmap
731 int width
= image
.GetWidth();
732 int height
= image
.GetHeight();
736 Create( width
, height
, 32 ) ;
739 GDHandle origDevice
;
741 PixMapHandle pixMap
= GetGWorldPixMap((GWorldPtr
)GetHBITMAP()) ;
742 LockPixels( pixMap
);
744 GetGWorld( &origPort
, &origDevice
) ;
745 SetGWorld( (GWorldPtr
) GetHBITMAP() , NULL
) ;
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
++)
753 for (int x
= 0; x
< width
; x
++)
756 *destination
++ = *data
++ ;
757 *destination
++ = *data
++ ;
758 *destination
++ = *data
++ ;
760 destinationBase
+= ((**pixMap
).rowBytes
& 0x7fff);
761 destination
= (unsigned char*) destinationBase
;
763 if ( image
.HasAlpha() )
765 unsigned char *alpha
= image
.GetAlpha();
767 wxColour
maskcolor(image
.GetMaskRed(), image
.GetMaskGreen(), image
.GetMaskBlue());
769 wxBitmap maskBitmap
;
771 maskBitmap
.Create( width
, height
, 24);
772 LockPixels( GetGWorldPixMap( (GWorldPtr
) maskBitmap
.GetHBITMAP()) );
773 SetGWorld( (GWorldPtr
) maskBitmap
.GetHBITMAP(), NULL
);
775 for (int y
= 0; y
< height
; y
++)
777 for (int x
= 0; x
< width
; x
++)
779 memset( &color
, 255 - *alpha
, sizeof( color
) );
780 SetCPixel(x
,y
, &color
);
785 SetGWorld( (GWorldPtr
) GetHBITMAP(), NULL
);
786 SetMask(new wxMask( maskBitmap
));
787 UnlockPixels( GetGWorldPixMap( (GWorldPtr
) maskBitmap
.GetHBITMAP()) );
789 else if ( image
.HasMask() )
791 data
= image
.GetData();
793 wxColour
maskcolor(image
.GetMaskRed(), image
.GetMaskGreen(), image
.GetMaskBlue());
794 RGBColor white
= { 0xffff, 0xffff, 0xffff };
795 RGBColor black
= { 0 , 0 , 0 };
796 wxBitmap maskBitmap
;
798 maskBitmap
.Create( width
, height
, 1);
799 LockPixels( GetGWorldPixMap( (GWorldPtr
) maskBitmap
.GetHBITMAP()) );
800 SetGWorld( (GWorldPtr
) maskBitmap
.GetHBITMAP(), NULL
);
802 for (int y
= 0; y
< height
; y
++)
804 for (int x
= 0; x
< width
; x
++)
806 if ( data
[0] == image
.GetMaskRed() && data
[1] == image
.GetMaskGreen() && data
[2] == image
.GetMaskBlue() )
808 SetCPixel(x
,y
, &white
);
811 SetCPixel(x
,y
, &black
);
816 SetGWorld( (GWorldPtr
) GetHBITMAP(), NULL
);
817 SetMask(new wxMask( maskBitmap
));
818 UnlockPixels( GetGWorldPixMap( (GWorldPtr
) maskBitmap
.GetHBITMAP()) );
821 UnlockPixels( GetGWorldPixMap( (GWorldPtr
) GetHBITMAP()) );
822 SetGWorld( origPort
, origDevice
);
825 wxImage
wxBitmap::ConvertToImage() const
829 wxCHECK_MSG( Ok(), wxNullImage
, wxT("invalid bitmap") );
831 // create an wxImage object
832 int width
= GetWidth();
833 int height
= GetHeight();
834 image
.Create( width
, height
);
836 unsigned char *data
= image
.GetData();
838 wxCHECK_MSG( data
, wxNullImage
, wxT("Could not allocate data for image") );
842 RgnHandle maskRgn
= NULL
;
843 GWorldPtr tempPort
= NULL
;
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;
849 wxMask
*mask
= GetMask();
851 GetGWorld( &origPort
, &origDevice
);
852 if ( GetBitmapType() != kMacBitmapTypeGrafWorld
)
854 tempPort
= wxMacCreateGWorld( width
, height
, -1) ;
858 tempPort
= (GWorldPtr
) GetHBITMAP() ;
860 LockPixels(GetGWorldPixMap(tempPort
));
861 SetGWorld( tempPort
, NULL
);
862 if ( GetBitmapType() == kMacBitmapTypePict
|| GetBitmapType() == kMacBitmapTypeIcon
)
864 Rect bitmaprect
= { 0 , 0 , height
, width
};
865 if ( GetBitmapType() == kMacBitmapTypeIcon
)
867 ::PlotCIconHandle( &bitmaprect
, atNone
, ttNone
, MAC_WXHICON(GetHICON()) ) ;
869 BitMapToRegion( maskRgn
, &(**(MAC_WXHICON(GetHICON()))).iconMask
) ;
872 ::DrawPicture( (PicHandle
) GetPict(), &bitmaprect
) ;
874 // Copy data into image
876 for (int yy
= 0; yy
< height
; yy
++)
878 for (int xx
= 0; xx
< width
; xx
++)
880 GetCPixel(xx
,yy
, &color
);
881 r
= ((color
.red
) >> 8);
882 g
= ((color
.green
) >> 8);
883 b
= ((color
.blue
) >> 8);
892 if ( !PtInRgn( pt
, maskRgn
) )
894 data
[index
] = mask_r
;
895 data
[index
+ 1] = mask_g
;
896 data
[index
+ 2] = mask_b
;
903 if (mask
->PointMasked(xx
,yy
))
905 data
[index
] = mask_r
;
906 data
[index
+ 1] = mask_g
;
907 data
[index
+ 2] = mask_b
;
914 if (mask
|| maskRgn
)
916 image
.SetMaskColour( mask_r
, mask_g
, mask_b
);
917 image
.SetMask( true );
921 UnlockPixels(GetGWorldPixMap( tempPort
));
922 SetGWorld(origPort
, origDevice
);
923 if ( GetBitmapType() != kMacBitmapTypeGrafWorld
)
925 wxMacDestroyGWorld( tempPort
) ;
929 DisposeRgn( maskRgn
) ;
936 bool wxBitmap::SaveFile(const wxString
& filename
, wxBitmapType type
,
937 const wxPalette
*palette
) const
939 wxBitmapHandler
*handler
= FindHandler(type
);
943 return handler
->SaveFile(this, filename
, type
, palette
);
947 wxImage image
= ConvertToImage();
949 return image
.SaveFile(filename
, type
);
952 wxLogWarning(wxT("no bitmap handler for type %d defined."), type
);
956 bool wxBitmap::Ok() const
958 return (M_BITMAPDATA
&& M_BITMAPDATA
->m_ok
);
961 int wxBitmap::GetHeight() const
963 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
965 return M_BITMAPDATA
->m_height
;
968 int wxBitmap::GetWidth() const
970 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
972 return M_BITMAPDATA
->m_width
;
975 int wxBitmap::GetDepth() const
977 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
979 return M_BITMAPDATA
->m_depth
;
982 int wxBitmap::GetQuality() const
984 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
986 return M_BITMAPDATA
->m_quality
;
989 wxMask
*wxBitmap::GetMask() const
991 wxCHECK_MSG( Ok(), (wxMask
*) NULL
, wxT("invalid bitmap") );
993 return M_BITMAPDATA
->m_bitmapMask
;
996 void wxBitmap::SetWidth(int w
)
999 m_refData
= new wxBitmapRefData
;
1001 M_BITMAPDATA
->m_width
= w
;
1004 void wxBitmap::SetHeight(int h
)
1007 m_refData
= new wxBitmapRefData
;
1009 M_BITMAPDATA
->m_height
= h
;
1012 void wxBitmap::SetDepth(int d
)
1015 m_refData
= new wxBitmapRefData
;
1017 M_BITMAPDATA
->m_depth
= d
;
1020 void wxBitmap::SetQuality(int q
)
1023 m_refData
= new wxBitmapRefData
;
1025 M_BITMAPDATA
->m_quality
= q
;
1028 void wxBitmap::SetOk(bool isOk
)
1031 m_refData
= new wxBitmapRefData
;
1033 M_BITMAPDATA
->m_ok
= isOk
;
1037 wxPalette
*wxBitmap::GetPalette() const
1039 wxCHECK_MSG( Ok(), NULL
, wxT("Invalid bitmap GetPalette()") );
1041 return &M_BITMAPDATA
->m_bitmapPalette
;
1044 void wxBitmap::SetPalette(const wxPalette
& palette
)
1047 m_refData
= new wxBitmapRefData
;
1049 M_BITMAPDATA
->m_bitmapPalette
= palette
;
1051 #endif // wxUSE_PALETTE
1053 void wxBitmap::SetMask(wxMask
*mask
)
1056 m_refData
= new wxBitmapRefData
;
1058 // Remove existing mask if there is one.
1059 delete M_BITMAPDATA
->m_bitmapMask
;
1061 M_BITMAPDATA
->m_bitmapMask
= mask
;
1064 WXHBITMAP
wxBitmap::GetHBITMAP() const
1066 wxCHECK_MSG( Ok(), NULL
, wxT("invalid bitmap") );
1068 return MAC_WXHBITMAP(M_BITMAPDATA
->m_hBitmap
);
1071 WXHMETAFILE
wxBitmap::GetPict( bool *created
) const
1073 wxCHECK_MSG( Ok(), NULL
, wxT("invalid bitmap") );
1075 PicHandle picture
= NULL
; // This is the returned picture
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
;
1082 else if(M_BITMAPDATA
->m_bitmapType
!= kMacBitmapTypeGrafWorld
) {
1090 picture
= wxMacCreatePict( MAC_WXHBITMAP(M_BITMAPDATA
->m_hBitmap
) , MAC_WXHBITMAP(GetMask()->GetMaskBitmap() ) ) ;
1094 picture
= wxMacCreatePict( MAC_WXHBITMAP(M_BITMAPDATA
->m_hBitmap
) , NULL
) ;
1096 if ( created
&& picture
)
1107 : m_maskBitmap(NULL
)
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
)
1116 Create(bitmap
, colour
);
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
)
1124 Create(bitmap
, paletteIndex
);
1127 // Construct a mask from a mono bitmap (copies the bitmap).
1128 wxMask::wxMask(const wxBitmap
& bitmap
)
1129 : m_maskBitmap(NULL
)
1138 wxMacDestroyGWorld( (GWorldPtr
) m_maskBitmap
) ;
1139 m_maskBitmap
= NULL
;
1143 // Create a mask from a mono bitmap (copies the bitmap).
1144 bool wxMask::Create(const wxBitmap
& bitmap
)
1148 wxMacDestroyGWorld( (GWorldPtr
) m_maskBitmap
) ;
1149 m_maskBitmap
= NULL
;
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
1155 wxCHECK_MSG( bitmap
.Ok(), false, wxT("Invalid bitmap"));
1157 m_depth
= bitmap
.GetDepth() ;
1158 m_maskBitmap
= wxMacCreateGWorld(bitmap
.GetWidth(), bitmap
.GetHeight(), bitmap
.GetDepth() );
1159 Rect rect
= { 0,0, bitmap
.GetHeight(), bitmap
.GetWidth() };
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()) );
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
)
1177 wxCHECK_MSG( 0, false, wxT("wxMask::Create not yet implemented"));
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
)
1187 wxMacDestroyGWorld( (GWorldPtr
) m_maskBitmap
) ;
1188 m_maskBitmap
= NULL
;
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
1194 wxCHECK_MSG( bitmap
.Ok(), false, wxT("Illigal bitmap"));
1196 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());
1202 // this is not very efficient, but I can't think
1203 // of a better way of doing it
1205 GDHandle origDevice
;
1207 RGBColor colors
[2] = {
1208 { 0xFFFF, 0xFFFF, 0xFFFF },
1211 GetGWorld( &origPort
, &origDevice
) ;
1212 for (int w
= 0; w
< bitmap
.GetWidth(); w
++)
1214 for (int h
= 0; h
< bitmap
.GetHeight(); h
++)
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
)
1221 SetCPixel( w
, h
, &colors
[0] ) ;
1225 SetCPixel( w
, h
, &colors
[1] ) ;
1229 UnlockPixels( GetGWorldPixMap( (CGrafPtr
) m_maskBitmap
) ) ;
1230 UnlockPixels( GetGWorldPixMap( (GWorldPtr
) bitmap
.GetHBITMAP() ) ) ;
1231 SetGWorld( origPort
, origDevice
) ;
1236 bool wxMask::PointMasked(int x
, int y
)
1239 GDHandle origDevice
;
1243 GetGWorld( &origPort
, &origDevice
);
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
));
1252 SetGWorld( origPort
, origDevice
);
1261 wxBitmapHandler::~wxBitmapHandler()
1265 bool wxBitmapHandler::Create(wxBitmap
*bitmap
, void *data
, long type
, int width
, int height
, int depth
)
1270 bool wxBitmapHandler::LoadFile(wxBitmap
*bitmap
, const wxString
& name
, long flags
,
1271 int desiredWidth
, int desiredHeight
)
1276 bool wxBitmapHandler::SaveFile(const wxBitmap
*bitmap
, const wxString
& name
, int type
, const wxPalette
*palette
)
1285 class WXDLLEXPORT wxPICTResourceHandler
: public wxBitmapHandler
1287 DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler
)
1289 inline wxPICTResourceHandler()
1291 m_name
= wxT("Macintosh Pict resource");
1292 m_extension
= wxEmptyString
;
1293 m_type
= wxBITMAP_TYPE_PICT_RESOURCE
;
1296 virtual bool LoadFile(wxBitmap
*bitmap
, const wxString
& name
, long flags
,
1297 int desiredWidth
, int desiredHeight
);
1299 IMPLEMENT_DYNAMIC_CLASS(wxPICTResourceHandler
, wxBitmapHandler
)
1301 bool wxPICTResourceHandler::LoadFile(wxBitmap
*bitmap
, const wxString
& name
, long flags
,
1302 int desiredWidth
, int desiredHeight
)
1305 wxMacStringToPascal( name
, theName
) ;
1307 PicHandle thePict
= (PicHandle
) GetNamedResource( 'PICT' , theName
) ;
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
;
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;
1329 void wxBitmap::InitStandardHandlers()
1331 AddHandler(new wxPICTResourceHandler
) ;
1332 AddHandler(new wxICONResourceHandler
) ;
1335 // ----------------------------------------------------------------------------
1336 // raw bitmap access support
1337 // ----------------------------------------------------------------------------
1339 void *wxBitmap::GetRawData(wxPixelDataBase
& data
, int bpp
)
1343 // no bitmap, no data (raw or otherwise)
1347 if ( M_BITMAPDATA
->m_bitmapType
!= kMacBitmapTypeGrafWorld
)
1349 wxFAIL_MSG( _T("GetRawData() only supported for GWorlds") );
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?") );
1359 wxCHECK_MSG( (*hPixMap
)->pixelSize
== bpp
, NULL
,
1360 _T("GetRawData(): pixel format mismatch") );
1362 if ( !LockPixels(hPixMap
) )
1364 wxFAIL_MSG( _T("failed to lock PixMap in GetRawData()") );
1369 data
.m_width
= GetWidth();
1370 data
.m_height
= GetHeight();
1371 data
.m_stride
= (*hPixMap
)->rowBytes
& 0x7fff;
1373 M_BITMAPDATA
->m_hasAlpha
= false;
1375 return GetPixBaseAddr(hPixMap
);
1378 void wxBitmap::UngetRawData(wxPixelDataBase
& dataBase
)
1383 if ( M_BITMAPDATA
->m_hasAlpha
)
1385 wxAlphaPixelData
& data
= (wxAlphaPixelData
&)dataBase
;
1387 int w
= data
.GetWidth(),
1388 h
= data
.GetHeight();
1390 wxBitmap
bmpMask(GetWidth(), GetHeight(), 32);
1391 wxAlphaPixelData
dataMask(bmpMask
, data
.GetOrigin(), wxSize(w
, h
));
1392 wxAlphaPixelData::Iterator
pMask(dataMask
),
1394 for ( int y
= 0; y
< h
; y
++ )
1396 wxAlphaPixelData::Iterator rowStartMask
= pMask
,
1399 for ( int x
= 0; x
< w
; x
++ )
1401 const wxAlphaPixelData::Iterator::ChannelType
1404 pMask
.Red() = alpha
;
1405 pMask
.Green() = alpha
;
1406 pMask
.Blue() = alpha
;
1415 pMask
= rowStartMask
;
1416 pMask
.OffsetY(dataMask
, 1);
1419 SetMask(new wxMask(bmpMask
));
1422 GWorldPtr gworld
= MAC_WXHBITMAP(M_BITMAPDATA
->m_hBitmap
);
1423 PixMapHandle hPixMap
= GetGWorldPixMap(gworld
);
1426 UnlockPixels(hPixMap
);
1430 void wxBitmap::UseAlpha()
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;