// Created: 2003/07/19
// RCS-ID: $Id$
// Copyright: (c) 2003 David Elliott
-// Licence: wxWidgets licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/wxprec.h"
#include "wx/cocoa/autorelease.h"
#include "wx/cocoa/string.h"
+#include "wx/cocoa/ObjcRef.h"
#import <AppKit/NSBitmapImageRep.h>
#import <AppKit/NSGraphics.h>
// ========================================================================
// wxBitmapRefData
// ========================================================================
+
class wxBitmapRefData: public wxGDIRefData
{
friend class wxBitmap;
wxBitmapRefData( const wxBitmapRefData& data );
virtual ~wxBitmapRefData();
+ virtual bool IsOk() const { return m_ok; }
+
protected:
int m_width;
int m_height;
wxMask *m_bitmapMask; // Optional mask
};
-#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
-
wxBitmapRefData::wxBitmapRefData()
{
m_ok = FALSE;
wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
{
+ wxAutoNSAutoreleasePool pool;
+
m_width = data.m_width;
m_height = data.m_height;
m_depth = data.m_depth;
m_numColors = data.m_numColors;
m_bitmapPalette = data.m_bitmapPalette;
m_quality = data.m_quality;
- m_cocoaNSBitmapImageRep = [data.m_cocoaNSBitmapImageRep copyWithZone:nil];
+ m_cocoaNSBitmapImageRep = wxGCSafeRetain([[data.m_cocoaNSBitmapImageRep copyWithZone:nil] autorelease]);
m_bitmapMask = data.m_bitmapMask?new wxMask(*data.m_bitmapMask):NULL;
}
wxBitmapRefData::~wxBitmapRefData()
{
- [m_cocoaNSBitmapImageRep release];
+ wxGCSafeRelease(m_cocoaNSBitmapImageRep);
m_cocoaNSBitmapImageRep = NULL;
delete m_bitmapMask;
// ========================================================================
// wxBitmap
// ========================================================================
+
+#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
+
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
wxBitmap::wxBitmap()
/* TODO: create the bitmap from data */
}
-wxBitmap::wxBitmap(int w, int h, int d)
+wxBitmap::wxBitmap(NSImage* cocoaNSImage)
+{
+ (void) Create(cocoaNSImage);
+}
+
+wxBitmap::wxBitmap(NSBitmapImageRep* cocoaNSBitmapImageRep)
{
- (void)Create(w, h, d);
+ (void) Create(cocoaNSBitmapImageRep);
}
wxBitmap::wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth)
LoadFile(filename, type);
}
-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBitmapRefData(*(wxBitmapRefData*)data);
}
WX_NSImage wxBitmap::GetNSImage(bool useMask) const
{
- if(!Ok())
+ if(!IsOk())
return nil;
NSImage *nsimage = [[[NSImage alloc]
initWithSize:NSMakeSize(GetWidth(), GetHeight())] autorelease];
if(!M_BITMAPDATA)
return;
// NOTE: No checking is done to make sure width/height agree
- [bitmapImageRep retain];
- [M_BITMAPDATA->m_cocoaNSBitmapImageRep release];
+ wxGCSafeRetain(bitmapImageRep);
+ wxGCSafeRelease(M_BITMAPDATA->m_cocoaNSBitmapImageRep);
M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImageRep;
}
M_BITMAPDATA->m_bitmapMask = mask ;
}
-bool wxBitmap::Ok() const
-{
- return m_refData && M_BITMAPDATA->m_ok;
-}
-
wxPalette* wxBitmap::GetPalette() const
{
if(!m_refData)
bool wxBitmap::Create(int w, int h, int d)
{
+ wxAutoNSAutoreleasePool pool;
+
UnRef();
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_depth = d;
/* TODO: create new bitmap */
- M_BITMAPDATA->m_cocoaNSBitmapImageRep = [[NSBitmapImageRep alloc]
+ M_BITMAPDATA->m_cocoaNSBitmapImageRep = wxGCSafeRetain([[[NSBitmapImageRep alloc]
initWithBitmapDataPlanes: NULL
pixelsWide: w
pixelsHigh: h
colorSpaceName: NSCalibratedRGBColorSpace
bytesPerRow: 0 // NOTE: Contrary to Apple documentation Mac OS
// 10.4 will add padding bytes when 0 is used here
- bitsPerPixel: 0];
+ bitsPerPixel: 0] autorelease]);
wxLogTrace(wxTRACE_COCOA,wxT("M_BITMAPDATA=%p NSBitmapImageRep bitmapData=%p"), M_BITMAPDATA, [M_BITMAPDATA->m_cocoaNSBitmapImageRep bitmapData]);
M_BITMAPDATA->m_ok = true;
M_BITMAPDATA->m_ok = true;
M_BITMAPDATA->m_numColors = 0;
M_BITMAPDATA->m_quality = 0;
- M_BITMAPDATA->m_cocoaNSBitmapImageRep = [imageRep retain];
+ M_BITMAPDATA->m_cocoaNSBitmapImageRep = wxGCSafeRetain(imageRep);
M_BITMAPDATA->m_bitmapMask = NULL;
return true;
}
wxImage image;
if(!image.LoadFile(filename,type))
return false;
- if(!image.Ok())
+ if(!image.IsOk())
return false;
*this = wxBitmap(image);
return true;
}
+bool wxBitmap::Create(NSImage* cocoaNSImage)
+{
+ wxAutoNSAutoreleasePool pool;
+ NSBitmapImageRep *bitmapImageRep = [NSBitmapImageRep imageRepWithData:[cocoaNSImage TIFFRepresentation]];
+ return Create(bitmapImageRep);
+}
+
+bool wxBitmap::Create(NSBitmapImageRep *imageRep)
+{
+ UnRef();
+ m_refData = new wxBitmapRefData;
+ if(imageRep != nil)
+ {
+ M_BITMAPDATA->m_width = [imageRep pixelsWide];
+ M_BITMAPDATA->m_height = [imageRep pixelsHigh];
+ M_BITMAPDATA->m_depth = [imageRep bitsPerPixel];
+ M_BITMAPDATA->m_ok = true;
+ M_BITMAPDATA->m_numColors = 0;
+ M_BITMAPDATA->m_quality = 0;
+ M_BITMAPDATA->m_cocoaNSBitmapImageRep = wxGCSafeRetain(imageRep);
+ M_BITMAPDATA->m_bitmapMask = NULL;
+ return true;
+ }
+ else
+ return false;
+}
+
bool wxBitmap::Create(const void* data, wxBitmapType type, int width, int height, int depth)
{
UnRef();
bool wxBitmap::CopyFromIcon(const wxIcon& icon)
{
+ // Pool here due to lack of one during wx init phase
+ wxAutoNSAutoreleasePool pool;
+
UnRef();
if(!icon.GetNSImage());
[icon.GetNSImage() lockFocus];
NSRect imageRect;
imageRect.origin.x = imageRect.origin.y = 0.0;
imageRect.size = [icon.GetNSImage() size];
- NSBitmapImageRep *newBitmapRep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect];
+ NSBitmapImageRep *newBitmapRep = [[[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect] autorelease];
[icon.GetNSImage() unlockFocus];
if(!newBitmapRep)
return false;
m_refData = new wxBitmapRefData;
- M_BITMAPDATA->m_cocoaNSBitmapImageRep = newBitmapRep;
+ M_BITMAPDATA->m_cocoaNSBitmapImageRep = wxGCSafeRetain(newBitmapRep);
M_BITMAPDATA->m_width = [newBitmapRep pixelsWide];
M_BITMAPDATA->m_height = [newBitmapRep pixelsHigh];
M_BITMAPDATA->m_depth = [newBitmapRep bitsPerSample]*[newBitmapRep samplesPerPixel];
return true;
}
-wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
+wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
{
- return wxNullBitmap;
+ wxAutoNSAutoreleasePool pool;
+ if(!IsOk())
+ return wxNullBitmap;
+ NSImage *nsimage = GetNSImage(false);
+
+ [nsimage lockFocus];
+ NSRect imageRect = {{0,0}, [nsimage size]};
+ imageRect.origin.x = imageRect.size.width * rect.x / GetWidth();
+ imageRect.origin.y = imageRect.size.height * rect.y / GetHeight();
+ imageRect.size.width *= static_cast<CGFloat>(rect.width) / GetWidth();
+ imageRect.size.height *= static_cast<CGFloat>(rect.height) / GetHeight();
+
+ NSBitmapImageRep *newBitmapRep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect];
+ [nsimage unlockFocus];
+
+ wxBitmap newBitmap(newBitmapRep);
+
+ return (newBitmap);
}
wxImage wxBitmap::ConvertToImage() const
{
wxAutoNSAutoreleasePool pool;
- if(!Ok())
+ if(!IsOk())
return /*wxImage(5,5)*/wxNullImage;
NSImage *nsimage = GetNSImage(false /* don't use mask */);
wxImage newImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
{
+ wxAutoNSAutoreleasePool pool;
UnRef();
- wxCHECK_MSG(image.Ok(), false, wxT("invalid image"));
+ wxCHECK_MSG(image.IsOk(), false, wxT("invalid image"));
wxCHECK_MSG(depth == -1 || depth == 1, false, wxT("invalid bitmap depth"));
m_refData = new wxBitmapRefData();
M_BITMAPDATA->m_width = image.GetWidth();
M_BITMAPDATA->m_height = image.GetHeight();
- NSBitmapImageRep *bitmapImage = [[NSBitmapImageRep alloc]
+ NSBitmapImageRep *bitmapImage = [[[NSBitmapImageRep alloc]
initWithBitmapDataPlanes: NULL
pixelsWide: image.GetWidth()
pixelsHigh: image.GetHeight()
isPlanar: NO
colorSpaceName: NSCalibratedRGBColorSpace
bytesPerRow: image.GetWidth()*3
- bitsPerPixel: 0];
+ bitsPerPixel: 0] autorelease];
// TODO: Specify bytesPerRow:0 and then use [bitmapImage bytesPerRow]
// so that the rows are aligned suitably for altivec by the OS (Tiger)
M_BITMAPDATA->m_ok = true;
M_BITMAPDATA->m_numColors = 0;
M_BITMAPDATA->m_quality = 0;
- M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImage;
+ M_BITMAPDATA->m_cocoaNSBitmapImageRep = wxGCSafeRetain(bitmapImage);
M_BITMAPDATA->m_bitmapMask = new wxMask(*this,wxColour(image.GetMaskRed(),image.GetMaskGreen(),image.GetMaskBlue()));
return true;
}
void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
{
- if(!Ok())
+ if(!IsOk())
return NULL;
NSBitmapImageRep *bitmapRep = M_BITMAPDATA->m_cocoaNSBitmapImageRep;
if([bitmapRep bitsPerPixel]!=bpp)
{
- wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") );
+ wxFAIL_MSG( wxT("incorrect bitmap type in wxBitmap::GetRawData()") );
return NULL;
}
data.m_width = [bitmapRep pixelsWide];
{ // TODO
}
-void wxBitmap::UseAlpha()
-{ // TODO
-}
-
// ========================================================================
// wxMask
// ========================================================================
Create(bitmap);
}
+// Copy constructor
+wxMask::wxMask(const wxMask& src)
+: wxObject(src)
+, m_cocoaNSBitmapImageRep(wxGCSafeRetain(src.m_cocoaNSBitmapImageRep))
+{
+}
+
wxMask::~wxMask()
{
- [m_cocoaNSBitmapImageRep release];
+ wxGCSafeRelease(m_cocoaNSBitmapImageRep);
}
// Create a mask from a mono bitmap (copies the bitmap).
bool wxMask::Create(const wxBitmap& bitmap)
{
// TODO
+ wxLogDebug(wxT("Cannot yet create a mask from a mono bitmap"));
return FALSE;
}
bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
{
// TODO
+ wxLogDebug(wxT("Cannot yet create a mask from a palette bitmap"));
return FALSE;
}
bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
{
wxAutoNSAutoreleasePool pool;
- if(!bitmap.Ok())
+ if(!bitmap.IsOk())
return false;
int bmpWidth = bitmap.GetWidth();
int bmpHeight = bitmap.GetHeight();
wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
false, wxT("Unable to access raw data"));
}
+ else if([srcBitmapRep bitsPerPixel]==8 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==1 && [srcBitmapRep hasAlpha]==NO)
+ // 8-bpp Grayscale, no alpha
+ { // Force all RGB to access the same grayscale component
+ typedef wxPixelFormat<unsigned char,8,0,0,0> PixelFormat;
+ wxPixelData<wxBitmap,PixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
+ wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
+ false, wxT("Unable to access raw data"));
+ }
else
{ wxCHECK_MSG(false,false,wxT("Unimplemented pixel format")); }
// maskRep was autoreleased in case we had to exit quickly
- m_cocoaNSBitmapImageRep = [maskRep retain];
+ m_cocoaNSBitmapImageRep = wxGCSafeRetain(maskRep);
return true;
}
projects / wxWidgets.git / blobdiff