X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9a6e13a6f78fcc0fde57bddd409732e743ae6194..8e06b283ceba99daab0c8a8752cc7bbd77225eb1:/src/cocoa/bitmap.mm

diff --git a/src/cocoa/bitmap.mm b/src/cocoa/bitmap.mm
index 79ec8ebcf0..58f1c729fb 100644
--- a/src/cocoa/bitmap.mm
+++ b/src/cocoa/bitmap.mm
@@ -1,33 +1,40 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        src/cocoa/bitmap.cpp
+// Name:        src/cocoa/bitmap.mm
 // Purpose:     wxBitmap
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/07/19
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:     wxWidgets licence
 /////////////////////////////////////////////////////////////////////////////
 
 #include "wx/wxprec.h"
+
+#include "wx/bitmap.h"
+
 #ifndef WX_PRECOMP
     #include "wx/log.h"
     #include "wx/utils.h"
     #include "wx/palette.h"
     #include "wx/icon.h"
     #include "wx/colour.h"
+    #include "wx/image.h"
 #endif //WX_PRECOMP
-#include "wx/bitmap.h"
-#include "wx/image.h"
+
 #include "wx/xpmdecod.h"
 #include "wx/rawbmp.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/NSImage.h>
+#import <AppKit/NSColor.h>
+
+IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
 
 // ========================================================================
 // wxBitmapRefData
@@ -40,6 +47,8 @@ public:
     wxBitmapRefData( const wxBitmapRefData& data );
     virtual ~wxBitmapRefData();
 
+    virtual bool IsOk() const { return m_ok; }
+
 protected:
     int                 m_width;
     int                 m_height;
@@ -68,6 +77,8 @@ wxBitmapRefData::wxBitmapRefData()
 
 wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
 {
+    wxAutoNSAutoreleasePool pool;
+
     m_width = data.m_width;
     m_height = data.m_height;
     m_depth = data.m_depth;
@@ -75,13 +86,13 @@ wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
     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;
@@ -119,7 +130,17 @@ wxBitmap::wxBitmap(int w, int h, int d)
     (void)Create(w, h, d);
 }
 
-wxBitmap::wxBitmap(void *data, wxBitmapType type, int width, int height, int depth)
+wxBitmap::wxBitmap(NSImage* cocoaNSImage)
+{
+    (void) Create(cocoaNSImage);
+}
+
+wxBitmap::wxBitmap(NSBitmapImageRep* cocoaNSBitmapImageRep)
+{
+    (void) Create(cocoaNSBitmapImageRep);
+}
+
+wxBitmap::wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth)
 {
     (void) Create(data, type, width, height, depth);
 }
@@ -129,12 +150,12 @@ wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
     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);
 }
@@ -159,7 +180,7 @@ WX_NSImage wxBitmap::GetNSImage(bool useMask) const
     {
         // Show before/after to prove that the bitmap itself is not changed
         // even though we just composited onto the NSImage
-        wxLogTrace(wxTRACE_COCOA,"Before: bpp=%d",[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
+        wxLogTrace(wxTRACE_COCOA,wxT("Before: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
         NSImage *maskImage = [[NSImage alloc]
                 initWithSize:NSMakeSize(GetWidth(), GetHeight())];
         [maskImage addRepresentation: GetMask()->GetNSBitmapImageRep()];
@@ -167,7 +188,7 @@ WX_NSImage wxBitmap::GetNSImage(bool useMask) const
         [maskImage compositeToPoint:NSZeroPoint operation:NSCompositeDestinationIn];
         [nsimage unlockFocus];
         [maskImage release];
-        wxLogTrace(wxTRACE_COCOA,"After: bpp=%d",[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
+        wxLogTrace(wxTRACE_COCOA,wxT("After: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
     }
     return nsimage;
 }
@@ -177,8 +198,8 @@ void wxBitmap::SetNSBitmapImageRep(WX_NSBitmapImageRep bitmapImageRep)
     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;
 }
 
@@ -238,11 +259,6 @@ void wxBitmap::SetMask(wxMask *mask)
     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 
-bool wxBitmap::Ok() const
-{
-    return m_refData && M_BITMAPDATA->m_ok;
-}
-
 wxPalette* wxBitmap::GetPalette() const
 {
     if(!m_refData)
@@ -280,6 +296,8 @@ int wxBitmap::GetHeight() const
 
 bool wxBitmap::Create(int w, int h, int d)
 {
+    wxAutoNSAutoreleasePool pool;
+
     UnRef();
 
     m_refData = new wxBitmapRefData;
@@ -289,7 +307,7 @@ bool wxBitmap::Create(int w, int h, int d)
     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
@@ -298,8 +316,9 @@ bool wxBitmap::Create(int w, int h, int d)
             hasAlpha: NO
             isPlanar: NO
             colorSpaceName: NSCalibratedRGBColorSpace
-            bytesPerRow: 0
-            bitsPerPixel: 0];
+            bytesPerRow: 0  // NOTE: Contrary to Apple documentation Mac OS
+                            // 10.4 will add padding bytes when 0 is used here
+            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;
@@ -328,7 +347,7 @@ 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_cocoaNSBitmapImageRep = [imageRep retain];
+        M_BITMAPDATA->m_cocoaNSBitmapImageRep = wxGCSafeRetain(imageRep);
         M_BITMAPDATA->m_bitmapMask = NULL;
         return true;
     }
@@ -341,7 +360,34 @@ bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
     return true;
 }
 
-bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)
+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();
 
@@ -355,43 +401,82 @@ bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPal
     return false;
 }
 
-bool wxBitmap::CopyFromIcon(const wxIcon& icno)
+bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 {
-    return false;
-}
+    // Pool here due to lack of one during wx init phase
+    wxAutoNSAutoreleasePool pool;
 
-wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
-{
-    return wxNullBitmap;
+    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] autorelease];
+    [icon.GetNSImage() unlockFocus];
+    if(!newBitmapRep)
+        return false;
+    m_refData = new wxBitmapRefData;
+    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_ok = true;
+    M_BITMAPDATA->m_numColors = 0;
+    M_BITMAPDATA->m_quality = 0;
+    M_BITMAPDATA->m_bitmapMask = NULL;
+    return true;
 }
 
-wxImage wxBitmap::ConvertToImage() const
+wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
 {
+    wxAutoNSAutoreleasePool pool;
     if(!Ok())
-        return /*wxImage(5,5)*/wxNullImage;
-    return wxImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
-}
+        return wxNullBitmap;
+    NSImage *nsimage = GetNSImage(false);
 
-bool wxBitmap::CreateFromXpm(const char **xpm)
-{
-#if wxUSE_IMAGE && wxUSE_XPM
-    UnRef();
+    [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 *= wx_static_cast(CGFloat, rect.width) / GetWidth();
+    imageRect.size.height *= wx_static_cast(CGFloat, rect.height) / GetHeight();
 
-    wxCHECK_MSG( xpm, false, wxT("invalid XPM data") )
+    NSBitmapImageRep *newBitmapRep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect];
+    [nsimage unlockFocus];
 
-    wxXPMDecoder decoder;
-    wxImage img = decoder.ReadData(xpm);
-    wxCHECK_MSG( img.Ok(), false, wxT("invalid XPM data") )
+    wxBitmap newBitmap(newBitmapRep);
 
-    *this = wxBitmap(img);
-    return true;
-#else
-    return false;
-#endif
+    return (newBitmap);
+}
+
+wxImage wxBitmap::ConvertToImage() const
+{
+    wxAutoNSAutoreleasePool pool;
+    if(!Ok())
+        return /*wxImage(5,5)*/wxNullImage;
+    NSImage *nsimage = GetNSImage(false /* don't use mask */);
+    wxImage newImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
+    [nsimage lockFocus];
+    for(int i=0; i < M_BITMAPDATA->m_width; i++)
+    {
+        // Don't let the pool get too big as you'll notice we're creating
+        // two autoreleased NSColor objects with every iteration.
+        wxAutoNSAutoreleasePool loopPool;
+        for(int j=0; j < M_BITMAPDATA->m_height; j++)
+        {
+            NSColor *pixelColor = NSReadPixel(NSMakePoint(i,M_BITMAPDATA->m_height - j - 1));
+            NSColor *color = [pixelColor colorUsingColorSpaceName:NSCalibratedRGBColorSpace];
+            newImage.SetRGB(i,j,int([color redComponent]*255.0), int([color greenComponent]*255.0), int([color blueComponent]*255.0));
+        }
+    }
+    [nsimage unlockFocus];
+    return newImage;
 }
 
 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 {
+    wxAutoNSAutoreleasePool pool;
     UnRef();
 
     wxCHECK_MSG(image.Ok(), false, wxT("invalid image"));
@@ -401,7 +486,7 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 
     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()
@@ -410,9 +495,11 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
             hasAlpha: NO
             isPlanar: NO
             colorSpaceName: NSCalibratedRGBColorSpace
-            bytesPerRow: 0
-            bitsPerPixel: 0];
+            bytesPerRow: image.GetWidth()*3
+            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)
     const int numBytes = image.GetWidth()*image.GetHeight()*3;
     memcpy([bitmapImage bitmapData], image.GetData(), numBytes);
     // TODO: Alpha and convert to desired depth
@@ -420,7 +507,7 @@ 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_cocoaNSBitmapImageRep = bitmapImage;
+    M_BITMAPDATA->m_cocoaNSBitmapImageRep = wxGCSafeRetain(bitmapImage);
     M_BITMAPDATA->m_bitmapMask = new wxMask(*this,wxColour(image.GetMaskRed(),image.GetMaskGreen(),image.GetMaskBlue()));
     return true;
 }
@@ -492,15 +579,23 @@ wxMask::wxMask(const wxBitmap& bitmap)
     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;
 }
 
@@ -509,14 +604,15 @@ bool wxMask::Create(const wxBitmap& bitmap)
 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 {
 // TODO
+    wxLogDebug(wxT("Cannot yet create a mask from a palette bitmap"));
     return FALSE;
 }
 
-template <class PixelData>
+template <typename PixelData>
 static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colour, unsigned char *dstData)
 {
     wxCHECK_MSG(dstData,false,wxT("Couldn't access mask data"));
-    class PixelData::Iterator p(srcData);
+    typename PixelData::Iterator p(srcData);
     const int nRows = srcData.GetHeight();
     const int nCols = srcData.GetWidth();
     // Total number of bytes per destination column
@@ -525,7 +621,7 @@ static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colou
     const int width_aligned = nCols/8*8;
     for(int y=0; y<nRows; ++y)
     {
-        class PixelData::Iterator rowStart(p);
+        typename PixelData::Iterator rowStart(p);
         unsigned char *dstRow = dstData + y*dstRowLength;
         for(int x=0; x<width_aligned; x+=8)
         {
@@ -615,11 +711,18 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
         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;
 }
-