/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.cpp
// Purpose: wxBitmap
-// Author: AUTHOR
+// Author: Stefan Csomor
// Modified by:
-// Created: ??/??/98
+// Created: 1998-01-01
// RCS-ID: $Id$
-// Copyright: (c) AUTHOR
+// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
if ( mask )
{
+ Rect r ;
+ GetPortBounds( image , &r ) ;
LockPixels(GetGWorldPixMap(mask) ) ;
CopyBits(GetPortBitMapForCopyBits(mask) ,
- &(**icon).iconBMap , &imageBounds , &imageBounds, srcCopy , nil ) ;
+ &(**icon).iconBMap , &r , &r, srcCopy , nil ) ;
CopyBits(GetPortBitMapForCopyBits(mask) ,
- &(**icon).iconMask , &imageBounds , &imageBounds, srcCopy , nil ) ;
+ &(**icon).iconMask , &r , &r, srcCopy , nil ) ;
UnlockPixels(GetGWorldPixMap( mask ) ) ;
}
else
{
+ Rect r ;
+ GetPortBounds( image , &r ) ;
LockPixels(GetGWorldPixMap(image));
CopyBits(GetPortBitMapForCopyBits(image) ,
- &(**icon).iconBMap , &imageBounds , &imageBounds, srcCopy , nil ) ;
+ &(**icon).iconBMap , &r , &r, srcCopy , nil ) ;
CopyBits(GetPortBitMapForCopyBits(image) ,
- &(**icon).iconMask , &imageBounds , &imageBounds, srcCopy , nil ) ;
+ &(**icon).iconMask , &r , &r, srcCopy , nil ) ;
UnlockPixels(GetGWorldPixMap(image));
}
SetGWorld( wp , NULL ) ;
Rect portRect ;
- GetPortBounds( wp , &portRect ) ;
-
+ if ( clipRgn )
+ GetRegionBounds( clipRgn , &portRect ) ;
+ else
+ GetPortBounds( wp , &portRect ) ;
pict = OpenPicture(&portRect);
if(pict)
{
RGBForeColor( &black ) ;
RGBBackColor( &white ) ;
-
+
+ if ( clipRgn )
+ SetClip( clipRgn ) ;
+
LockPixels( GetGWorldPixMap( wp ) ) ;
CopyBits(GetPortBitMapForCopyBits(wp),
GetPortBitMapForCopyBits(wp),
ClosePicture();
}
SetGWorld( origPort , origDev ) ;
+ if ( clipRgn )
+ DisposeRgn( clipRgn ) ;
return pict;
}
-void wxMacCreateBitmapButton( ControlButtonContentInfo*info , const wxBitmap& bitmap )
+void wxMacCreateBitmapButton( ControlButtonContentInfo*info , const wxBitmap& bitmap , int forceType )
{
memset( info , 0 , sizeof(ControlButtonContentInfo) ) ;
if ( bitmap.Ok() )
}
else if ( bmap->m_bitmapType == kMacBitmapTypeGrafWorld )
{
- if ( (bmap->m_width == bmap->m_height) && (bmap->m_width & 0x3 == 0) )
+ if ( (forceType == kControlContentCIconHandle || ( bmap->m_width == bmap->m_height && forceType != kControlContentPictHandle ) ) && ((bmap->m_width & 0x3) == 0) )
{
info->contentType = kControlContentCIconHandle ;
if ( bitmap.GetMask() )
- {
+ {
info->u.cIconHandle = wxMacCreateCIcon( MAC_WXHBITMAP(bmap->m_hBitmap) , MAC_WXHBITMAP(bitmap.GetMask()->GetMaskBitmap()) ,
8 , bmap->m_width ) ;
}
info->contentType = kControlContentPictHandle ;
if ( bitmap.GetMask() )
{
- info->u.picture = wxMacCreatePict( MAC_WXHBITMAP(bmap->m_hBitmap) , MAC_WXHBITMAP(bitmap.GetMask()->GetMaskBitmap() ) ) ;
+ info->u.picture = wxMacCreatePict( MAC_WXHBITMAP(bmap->m_hBitmap) , MAC_WXHBITMAP(bitmap.GetMask()->GetMaskBitmap() ) ) ;
}
else
{
- info->u.picture = wxMacCreatePict( MAC_WXHBITMAP(bmap->m_hBitmap) , NULL ) ;
+ info->u.picture = wxMacCreatePict( MAC_WXHBITMAP(bmap->m_hBitmap) , NULL ) ;
}
}
}
- else if ( bmap->m_bitmapType == kMacBitmapTypeIcon )
- {
- info->contentType = kControlContentCIconHandle ;
- info->u.cIconHandle = MAC_WXHICON(bmap->m_hIcon) ;
- }
+ else if ( bmap->m_bitmapType == kMacBitmapTypeIcon )
+ {
+ info->contentType = kControlContentCIconHandle ;
+ info->u.cIconHandle = MAC_WXHICON(bmap->m_hIcon) ;
+ }
}
}
// TODO move this to a public function of Bitmap Ref
static void DisposeBitmapRefData(wxBitmapRefData *data)
{
+ if ( !data )
+ return ;
+
switch (data->m_bitmapType)
{
case kMacBitmapTypePict :
break ;
}
- if (data->m_bitmapMask)
- {
- delete data->m_bitmapMask;
- data->m_bitmapMask = NULL;
- }
+ if (data->m_bitmapMask)
+ {
+ delete data->m_bitmapMask;
+ data->m_bitmapMask = NULL;
+ }
}
wxBitmapRefData::~wxBitmapRefData()
RGBColor color;
mask = (GWorldPtr) GetMask()->GetMaskBitmap();
- submask = wxMacCreateGWorld(rect.width, rect.height, 1);
+ submask = wxMacCreateGWorld(rect.width, rect.height, GetMask()->GetDepth() );
LockPixels(GetGWorldPixMap(mask));
LockPixels(GetGWorldPixMap(submask));
void wxBitmap::SetHBITMAP(WXHBITMAP bmp)
{
- DisposeBitmapRefData( M_BITMAPDATA ) ;
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
+ else
+ DisposeBitmapRefData( M_BITMAPDATA ) ;
M_BITMAPDATA->m_bitmapType = kMacBitmapTypeGrafWorld ;
M_BITMAPDATA->m_hBitmap = bmp ;
- M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hBitmap != NULL ) ;
+ M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hBitmap != NULL ) ;
+}
+
+void wxBitmap::SetHICON(WXHICON ico)
+{
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
+ else
+ DisposeBitmapRefData( M_BITMAPDATA ) ;
+
+ M_BITMAPDATA->m_bitmapType = kMacBitmapTypeIcon ;
+ M_BITMAPDATA->m_hIcon = ico ;
+ M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hIcon != NULL ) ;
+}
+
+void wxBitmap::SetPict(WXHMETAFILE pict)
+{
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
+ else
+ DisposeBitmapRefData( M_BITMAPDATA ) ;
+
+ M_BITMAPDATA->m_bitmapType = kMacBitmapTypePict ;
+ M_BITMAPDATA->m_hPict = pict ;
+ M_BITMAPDATA->m_ok = ( M_BITMAPDATA->m_hPict != NULL ) ;
}
bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
return true;
}
}
- wxLogWarning("no bitmap handler for type %d defined.", type);
+ wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
return false;
}
wxBitmapHandler *handler = FindHandler(type);
if ( handler == NULL ) {
- wxLogWarning("no bitmap handler for type %d defined.", type);
+ wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
return FALSE;
}
destinationBase += ((**pixMap).rowBytes & 0x7fff);
destination = (unsigned char*) destinationBase ;
}
- if ( image.HasMask() )
+ if ( image.HasAlpha() )
+ {
+ unsigned char *alpha = image.GetAlpha();
+
+ wxColour maskcolor(image.GetMaskRed(), image.GetMaskGreen(), image.GetMaskBlue());
+ RGBColor color ;
+ wxBitmap maskBitmap ;
+
+ maskBitmap.Create( width, height, 24);
+ LockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) );
+ SetGWorld( (GWorldPtr) maskBitmap.GetHBITMAP(), NULL);
+
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ memset( &color , 255 - *alpha , sizeof( color ) );
+ SetCPixel(x,y, &color);
+
+ alpha += 1 ;
+ }
+ } // for height
+ SetGWorld( (GWorldPtr) GetHBITMAP(), NULL);
+ SetMask(new wxMask( maskBitmap ));
+ UnlockPixels( GetGWorldPixMap( (GWorldPtr) maskBitmap.GetHBITMAP()) );
+ }
+ else if ( image.HasMask() )
{
data = image.GetData();
SetCPixel(x,y, &white);
}
else {
- SetCPixel(x,y, &black);
+ SetCPixel(x,y, &black);
}
data += 3 ;
}
GWorldPtr origPort;
GDHandle origDevice;
+ RgnHandle maskRgn = NULL ;
+ GWorldPtr tempPort = NULL ;
int index;
RGBColor color;
// background color set to RGB(16,16,16) in consistent with wxGTK
wxMask *mask = GetMask();
GetGWorld( &origPort, &origDevice );
- LockPixels(GetGWorldPixMap( (GWorldPtr) GetHBITMAP()));
- SetGWorld( (GWorldPtr) GetHBITMAP(), NULL);
-
+ if ( GetBitmapType() != kMacBitmapTypeGrafWorld )
+ {
+ tempPort = wxMacCreateGWorld( width , height , -1) ;
+ }
+ else
+ {
+ tempPort = (GWorldPtr) GetHBITMAP() ;
+ }
+ LockPixels(GetGWorldPixMap(tempPort));
+ SetGWorld( tempPort, NULL);
+ if ( GetBitmapType() == kMacBitmapTypePict || GetBitmapType() == kMacBitmapTypeIcon )
+ {
+ Rect bitmaprect = { 0 , 0 , height, width };
+ if ( GetBitmapType() == kMacBitmapTypeIcon )
+ {
+ ::PlotCIconHandle( &bitmaprect , atNone , ttNone , MAC_WXHICON(GetHICON()) ) ;
+ maskRgn = NewRgn() ;
+ BitMapToRegion( maskRgn , &(**(MAC_WXHICON(GetHICON()))).iconMask ) ;
+ }
+ else
+ ::DrawPicture( (PicHandle) GetPict(), &bitmaprect ) ;
+ }
// Copy data into image
index = 0;
for (int yy = 0; yy < height; yy++)
data[index ] = r;
data[index + 1] = g;
data[index + 2] = b;
- if (mask)
- {
- if (mask->PointMasked(xx,yy))
+ if ( maskRgn )
+ {
+ Point pt ;
+ pt.h = xx ;
+ pt.v = yy ;
+ if ( !PtInRgn( pt , maskRgn ) )
{
data[index ] = mask_r;
data[index + 1] = mask_g;
data[index + 2] = mask_b;
}
}
+ else
+ {
+ if (mask)
+ {
+ if (mask->PointMasked(xx,yy))
+ {
+ data[index ] = mask_r;
+ data[index + 1] = mask_g;
+ data[index + 2] = mask_b;
+ }
+ }
+ }
index += 3;
}
}
- if (mask)
+ if (mask || maskRgn )
{
image.SetMaskColour( mask_r, mask_g, mask_b );
image.SetMask( true );
}
// Free resources
- UnlockPixels(GetGWorldPixMap( (GWorldPtr) GetHBITMAP()));
+ UnlockPixels(GetGWorldPixMap( tempPort ));
SetGWorld(origPort, origDevice);
+ if ( GetBitmapType() != kMacBitmapTypeGrafWorld )
+ {
+ wxMacDestroyGWorld( tempPort ) ;
+ }
+ if ( maskRgn )
+ {
+ DisposeRgn( maskRgn ) ;
+ }
return image;
}
return image.SaveFile(filename, type);
}
- wxLogWarning("no bitmap handler for type %d defined.", type);
+ wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
return false;
}
return MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap);
}
-WXHMETAFILE wxBitmap::GetPict() const
+WXHMETAFILE wxBitmap::GetPict( bool *created ) const
{
- wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
+ wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
- PicHandle picture; // This is the returned picture
-
- // If bitmap already in Pict format return pointer
- if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypePict) {
+ PicHandle picture = NULL ; // This is the returned picture
+ if ( created )
+ (*created) = false ;
+ // If bitmap already in Pict format return pointer
+ if(M_BITMAPDATA->m_bitmapType == kMacBitmapTypePict) {
return M_BITMAPDATA->m_hPict;
- }
- else if(M_BITMAPDATA->m_bitmapType != kMacBitmapTypeGrafWorld) {
+ }
+ else if(M_BITMAPDATA->m_bitmapType != kMacBitmapTypeGrafWorld) {
// Invalid bitmap
return NULL;
- }
-
- RGBColor gray = { 0xCCCC ,0xCCCC , 0xCCCC } ;
- RGBColor white = { 0xffff ,0xffff , 0xffff } ;
- RGBColor black = { 0x0000 ,0x0000 , 0x0000 } ;
- CGrafPtr origPort;
- GDHandle origDev ;
- wxMask *mask;
- Rect portRect ;
-
- GetPortBounds( (GWorldPtr) GetHBITMAP() , &portRect ) ;
- int width = portRect.right - portRect.left ;
- int height = portRect.bottom - portRect.top ;
-
- LockPixels( GetGWorldPixMap( (GWorldPtr) GetHBITMAP() ) ) ;
- GetGWorld( &origPort , &origDev ) ;
-
- mask = GetMask();
-
- SetGWorld( (GWorldPtr) GetHBITMAP() , NULL ) ;
-
- picture = OpenPicture(&portRect); // open a picture, this disables drawing
- if(!picture) {
- return NULL;
- }
-
- if( mask )
- {
-#ifdef __DARWIN__
- RGBColor trans = white;
-#else
- RGBBackColor( &gray );
- EraseRect( &portRect );
- RGBColor trans = gray;
-#endif
- RGBForeColor( &black ) ;
- RGBBackColor( &white ) ;
- PenMode(transparent);
-
- for ( int y = 0 ; y < height ; ++y )
- {
- for( int x = 0 ; x < width ; ++x )
- {
- if ( !mask->PointMasked(x,y) )
- {
- RGBColor col ;
-
- GetCPixel( x + portRect.left , y + portRect.top , &col ) ;
- SetCPixel( x + portRect.left , y + portRect.top , &col ) ;
- }
- else {
- // With transparency this sets a blank pixel
- SetCPixel( x + portRect.left , y + portRect.top , &trans);
- }
- }
- }
- }
- else
- {
- RGBBackColor( &gray ) ;
- EraseRect(&portRect);
- RGBForeColor( &black ) ;
- RGBBackColor( &white ) ;
-
- CopyBits(GetPortBitMapForCopyBits( (GWorldPtr) GetHBITMAP()),
- // src PixMap - we copy image over itself -
- GetPortBitMapForCopyBits( (GWorldPtr) GetHBITMAP()),
- // dst PixMap - no drawing occurs
- &portRect, // srcRect - it will be recorded and compressed -
- &portRect, // dstRect - into the picture that is open -
- srcCopy,NULL); // copyMode and no clip region
- }
- ClosePicture(); // We are done recording the picture
- UnlockPixels( GetGWorldPixMap( (GWorldPtr) GetHBITMAP() ) ) ;
- SetGWorld( origPort , origDev ) ;
-
- return picture; // return our groovy pict handle
+ }
+ else
+ {
+ if ( GetMask() )
+ {
+ picture = wxMacCreatePict( MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) , MAC_WXHBITMAP(GetMask()->GetMaskBitmap() ) ) ;
+ }
+ else
+ {
+ picture = wxMacCreatePict( MAC_WXHBITMAP(M_BITMAPDATA->m_hBitmap) , NULL ) ;
+ }
+ if ( created && picture )
+ (*created) = true ;
+ }
+ return picture ;
}
/*
wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap"));
- wxCHECK_MSG(bitmap.GetDepth() == 1, false,
- wxT("Cannot create mask from colour bitmap"));
-
- m_maskBitmap = wxMacCreateGWorld(bitmap.GetWidth(), bitmap.GetHeight(), 1);
+ m_depth = bitmap.GetDepth() ;
+ m_maskBitmap = wxMacCreateGWorld(bitmap.GetWidth(), bitmap.GetHeight(), bitmap.GetDepth() );
Rect rect = { 0,0, bitmap.GetHeight(), bitmap.GetWidth() };
LockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap) );
wxCHECK_MSG( bitmap.Ok(), false, wxT("Illigal bitmap"));
- m_maskBitmap = wxMacCreateGWorld( bitmap.GetWidth() , bitmap.GetHeight() , 1 );
+ m_maskBitmap = wxMacCreateGWorld( bitmap.GetWidth() , bitmap.GetHeight() , 1 );
+ m_depth = 1 ;
LockPixels( GetGWorldPixMap( (GWorldPtr) m_maskBitmap ) );
LockPixels( GetGWorldPixMap( (GWorldPtr) bitmap.GetHBITMAP() ) );
RGBColor maskColor = MAC_WXCOLORREF(colour.GetPixel());
public:
inline wxPICTResourceHandler()
{
- m_name = "Macintosh Pict resource";
- m_extension = "";
+ m_name = wxT("Macintosh Pict resource");
+ m_extension = wxEmptyString;
m_type = wxBITMAP_TYPE_PICT_RESOURCE;
};
int desiredWidth, int desiredHeight)
{
Str255 theName ;
-
-#if TARGET_CARBON
- c2pstrcpy( (StringPtr) theName , name ) ;
-#else
- strcpy( (char *) theName , name ) ;
- c2pstr( (char *)theName ) ;
-#endif
-
+ wxMacStringToPascal( name , theName ) ;
+
PicHandle thePict = (PicHandle ) GetNamedResource( 'PICT' , theName ) ;
if ( thePict )
{
projects / wxWidgets.git / blobdiff