Added ability to switch off more components of the size page UI

[wxWidgets.git] / src / cocoa / bitmap.mm

diff --git a/src/cocoa/bitmap.mm b/src/cocoa/bitmap.mm
index 05553108c4e74ac6f088606683719e3be445c99f..16ca2a7847e66eb0e1a13c899397984231f07f12 100644 (file)
--- a/src/cocoa/bitmap.mm
+++ b/src/cocoa/bitmap.mm
@@ -6,7 +6,7 @@
 // Created:     2003/07/19
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
 // Created:     2003/07/19
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott

-// Licence:     wxWidgets licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #include "wx/wxprec.h"
 /////////////////////////////////////////////////////////////////////////////
 
 #include "wx/wxprec.h"


@@ -27,6 +27,7 @@
 
 #include "wx/cocoa/autorelease.h"
 #include "wx/cocoa/string.h"
 
 #include "wx/cocoa/autorelease.h"
 #include "wx/cocoa/string.h"

+#include "wx/cocoa/ObjcRef.h"

 
 #import <AppKit/NSBitmapImageRep.h>
 #import <AppKit/NSGraphics.h>
 
 #import <AppKit/NSBitmapImageRep.h>
 #import <AppKit/NSGraphics.h>


@@ -38,6 +39,7 @@ IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
 // ========================================================================
 // wxBitmapRefData
 // ========================================================================
 // ========================================================================
 // wxBitmapRefData
 // ========================================================================

+

 class wxBitmapRefData: public wxGDIRefData
 {
     friend class wxBitmap;
 class wxBitmapRefData: public wxGDIRefData
 {
     friend class wxBitmap;


@@ -46,6 +48,8 @@ public:
     wxBitmapRefData( const wxBitmapRefData& data );
     virtual ~wxBitmapRefData();
 
     wxBitmapRefData( const wxBitmapRefData& data );
     virtual ~wxBitmapRefData();
 

+    virtual bool IsOk() const { return m_ok; }
+

 protected:
     int                 m_width;
     int                 m_height;
 protected:
     int                 m_width;
     int                 m_height;


@@ -58,8 +62,6 @@ protected:
     wxMask             *m_bitmapMask; // Optional mask
 };
 
     wxMask             *m_bitmapMask; // Optional mask
 };
 

-#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
-

 wxBitmapRefData::wxBitmapRefData()
 {
     m_ok = FALSE;
 wxBitmapRefData::wxBitmapRefData()
 {
     m_ok = FALSE;


@@ -74,6 +76,8 @@ wxBitmapRefData::wxBitmapRefData()
 
 wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
 {
 
 wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
 {

+    wxAutoNSAutoreleasePool pool;
+

     m_width = data.m_width;
     m_height = data.m_height;
     m_depth = data.m_depth;
     m_width = data.m_width;
     m_height = data.m_height;
     m_depth = data.m_depth;


@@ -81,13 +85,13 @@ wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
     m_numColors = data.m_numColors;
     m_bitmapPalette = data.m_bitmapPalette;
     m_quality = data.m_quality;
     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_bitmapMask = data.m_bitmapMask?new wxMask(*data.m_bitmapMask):NULL;
 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {

-    [m_cocoaNSBitmapImageRep release];
+    wxGCSafeRelease(m_cocoaNSBitmapImageRep);

     m_cocoaNSBitmapImageRep = NULL;
 
     delete m_bitmapMask;
     m_cocoaNSBitmapImageRep = NULL;
 
     delete m_bitmapMask;


@@ -97,6 +101,9 @@ wxBitmapRefData::~wxBitmapRefData()
 // ========================================================================
 // wxBitmap
 // ========================================================================
 // ========================================================================
 // wxBitmap
 // ========================================================================

+
+#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
+

 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 
 wxBitmap::wxBitmap()
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 
 wxBitmap::wxBitmap()


@@ -120,11 +127,6 @@ wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits
     /* TODO: create the bitmap from data */
 }
 
     /* TODO: create the bitmap from data */
 }
 

-wxBitmap::wxBitmap(int w, int h, int d)
-{
-    (void)Create(w, h, d);
-}
-

 wxBitmap::wxBitmap(NSImage* cocoaNSImage)
 {
     (void) Create(cocoaNSImage);
 wxBitmap::wxBitmap(NSImage* cocoaNSImage)
 {
     (void) Create(cocoaNSImage);


@@ -145,12 +147,12 @@ wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
     LoadFile(filename, type);
 }
 
     LoadFile(filename, type);
 }
 

-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const

 {
     return new wxBitmapRefData;
 }
 
 {
     return new wxBitmapRefData;
 }
 

-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const

 {
     return new wxBitmapRefData(*(wxBitmapRefData*)data);
 }
 {
     return new wxBitmapRefData(*(wxBitmapRefData*)data);
 }


@@ -164,7 +166,7 @@ WX_NSBitmapImageRep wxBitmap::GetNSBitmapImageRep()
 
 WX_NSImage wxBitmap::GetNSImage(bool useMask) const
 {
 
 WX_NSImage wxBitmap::GetNSImage(bool useMask) const
 {

-    if(!Ok())
+    if(!IsOk())

         return nil;
     NSImage *nsimage = [[[NSImage alloc]
             initWithSize:NSMakeSize(GetWidth(), GetHeight())] autorelease];
         return nil;
     NSImage *nsimage = [[[NSImage alloc]
             initWithSize:NSMakeSize(GetWidth(), GetHeight())] autorelease];


@@ -193,8 +195,8 @@ void wxBitmap::SetNSBitmapImageRep(WX_NSBitmapImageRep bitmapImageRep)
     if(!M_BITMAPDATA)
         return;
     // NOTE: No checking is done to make sure width/height agree
     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_cocoaNSBitmapImageRep = bitmapImageRep;
 }
 


@@ -254,11 +256,6 @@ void wxBitmap::SetMask(wxMask *mask)
     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 
     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 

-bool wxBitmap::IsOk() const
-{
-    return m_refData && M_BITMAPDATA->m_ok;
-}
-

 wxPalette* wxBitmap::GetPalette() const
 {
     if(!m_refData)
 wxPalette* wxBitmap::GetPalette() const
 {
     if(!m_refData)


@@ -296,6 +293,8 @@ int wxBitmap::GetHeight() const
 
 bool wxBitmap::Create(int w, int h, int d)
 {
 
 bool wxBitmap::Create(int w, int h, int d)
 {

+    wxAutoNSAutoreleasePool pool;
+

     UnRef();
 
     m_refData = new wxBitmapRefData;
     UnRef();
 
     m_refData = new wxBitmapRefData;


@@ -305,7 +304,7 @@ bool wxBitmap::Create(int w, int h, int d)
     M_BITMAPDATA->m_depth = d;
 
     /* TODO: create new bitmap */
     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
             initWithBitmapDataPlanes: NULL
             pixelsWide: w
             pixelsHigh: h


@@ -316,7 +315,7 @@ bool wxBitmap::Create(int w, int h, int d)
             colorSpaceName: NSCalibratedRGBColorSpace
             bytesPerRow: 0  // NOTE: Contrary to Apple documentation Mac OS
                             // 10.4 will add padding bytes when 0 is used here
             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;
 
     wxLogTrace(wxTRACE_COCOA,wxT("M_BITMAPDATA=%p NSBitmapImageRep bitmapData=%p"), M_BITMAPDATA, [M_BITMAPDATA->m_cocoaNSBitmapImageRep bitmapData]);
     M_BITMAPDATA->m_ok = true;


@@ -345,14 +344,14 @@ bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
         M_BITMAPDATA->m_ok = true;
         M_BITMAPDATA->m_numColors = 0;
         M_BITMAPDATA->m_quality = 0;
         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;
         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;
         return false;
     *this = wxBitmap(image);
     return true;


@@ -377,7 +376,7 @@ bool wxBitmap::Create(NSBitmapImageRep *imageRep)
         M_BITMAPDATA->m_ok = true;
         M_BITMAPDATA->m_numColors = 0;
         M_BITMAPDATA->m_quality = 0;
         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;
     }
         M_BITMAPDATA->m_bitmapMask = NULL;
         return true;
     }


@@ -410,12 +409,12 @@ bool wxBitmap::CopyFromIcon(const wxIcon& icon)
     NSRect imageRect;
     imageRect.origin.x = imageRect.origin.y = 0.0;
     imageRect.size = [icon.GetNSImage() size];
     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;
     [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];
     M_BITMAPDATA->m_width = [newBitmapRep pixelsWide];
     M_BITMAPDATA->m_height = [newBitmapRep pixelsHigh];
     M_BITMAPDATA->m_depth = [newBitmapRep bitsPerSample]*[newBitmapRep samplesPerPixel];


@@ -429,7 +428,7 @@ bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
 {
     wxAutoNSAutoreleasePool pool;
 wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
 {
     wxAutoNSAutoreleasePool pool;

-    if(!Ok())
+    if(!IsOk())

         return wxNullBitmap;
     NSImage *nsimage = GetNSImage(false);
 
         return wxNullBitmap;
     NSImage *nsimage = GetNSImage(false);
 


@@ -437,8 +436,8 @@ wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
     NSRect imageRect = {{0,0}, [nsimage size]};
     imageRect.origin.x = imageRect.size.width * rect.x / GetWidth();
     imageRect.origin.y = imageRect.size.height * rect.y / GetHeight();
     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 *= wx_static_cast(CGFloat, rect.width) / GetWidth();
-    imageRect.size.height *= wx_static_cast(CGFloat, rect.height) / 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];
 
     NSBitmapImageRep *newBitmapRep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect];
     [nsimage unlockFocus];


@@ -451,7 +450,7 @@ wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
 wxImage wxBitmap::ConvertToImage() const
 {
     wxAutoNSAutoreleasePool pool;
 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);
         return /*wxImage(5,5)*/wxNullImage;
     NSImage *nsimage = GetNSImage(false /* don't use mask */);
     wxImage newImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);


@@ -474,16 +473,17 @@ wxImage wxBitmap::ConvertToImage() const
 
 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 {
 
 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 {

+    wxAutoNSAutoreleasePool pool;

     UnRef();
 
     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();
     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()
             initWithBitmapDataPlanes: NULL
             pixelsWide: image.GetWidth()
             pixelsHigh: image.GetHeight()


@@ -493,7 +493,7 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
             isPlanar: NO
             colorSpaceName: NSCalibratedRGBColorSpace
             bytesPerRow: image.GetWidth()*3
             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)
 
     // TODO: Specify bytesPerRow:0 and then use [bitmapImage bytesPerRow]
     // so that the rows are aligned suitably for altivec by the OS (Tiger)


@@ -504,14 +504,14 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
     M_BITMAPDATA->m_ok = true;
     M_BITMAPDATA->m_numColors = 0;
     M_BITMAPDATA->m_quality = 0;
     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)
 {
     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;
         return NULL;
 
     NSBitmapImageRep *bitmapRep = M_BITMAPDATA->m_cocoaNSBitmapImageRep;


@@ -520,7 +520,7 @@ void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
 
     if([bitmapRep bitsPerPixel]!=bpp)
     {
 
     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];
         return NULL;
     }
     data.m_width = [bitmapRep pixelsWide];


@@ -579,13 +579,13 @@ wxMask::wxMask(const wxBitmap& bitmap)
 // Copy constructor
 wxMask::wxMask(const wxMask& src)
 :   wxObject(src)
 // Copy constructor
 wxMask::wxMask(const wxMask& src)
 :   wxObject(src)

-,   m_cocoaNSBitmapImageRep([src.m_cocoaNSBitmapImageRep retain])
+,   m_cocoaNSBitmapImageRep(wxGCSafeRetain(src.m_cocoaNSBitmapImageRep))

 {
 }
 
 wxMask::~wxMask()
 {
 {
 }
 
 wxMask::~wxMask()
 {

-    [m_cocoaNSBitmapImageRep release];
+    wxGCSafeRelease(m_cocoaNSBitmapImageRep);

 }
 
 // Create a mask from a mono bitmap (copies the bitmap).
 }
 
 // Create a mask from a mono bitmap (copies the bitmap).


@@ -657,7 +657,7 @@ static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colou
 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 {
     wxAutoNSAutoreleasePool pool;
 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();
         return false;
     int bmpWidth = bitmap.GetWidth();
     int bmpHeight = bitmap.GetHeight();


@@ -720,6 +720,6 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
     {   wxCHECK_MSG(false,false,wxT("Unimplemented pixel format")); }
 
     // maskRep was autoreleased in case we had to exit quickly
     {   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;
 }
     return true;
 }