X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/449c567346a1b3937e532cd87aac007faad76b04..631a05be911d510e256bf75819ca7a46e38fe203:/src/cocoa/bitmap.mm

diff --git a/src/cocoa/bitmap.mm b/src/cocoa/bitmap.mm
index c57e24e4f9..2d335f5548 100644
--- 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
-// Licence:     wxWindows licence
+// Licence:     wxWidgets licence
 /////////////////////////////////////////////////////////////////////////////
 
 #include "wx/wxprec.h"
@@ -15,16 +15,19 @@
     #include "wx/utils.h"
     #include "wx/palette.h"
     #include "wx/icon.h"
+    #include "wx/colour.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"
 
 #import <AppKit/NSBitmapImageRep.h>
 #import <AppKit/NSGraphics.h>
+#import <AppKit/NSImage.h>
 
 // ========================================================================
 // wxBitmapRefData
@@ -143,6 +146,32 @@ WX_NSBitmapImageRep wxBitmap::GetNSBitmapImageRep()
     return M_BITMAPDATA->m_cocoaNSBitmapImageRep;
 }
 
+WX_NSImage wxBitmap::GetNSImage(bool useMask) const
+{
+    if(!Ok())
+        return nil;
+    NSImage *nsimage = [[[NSImage alloc]
+            initWithSize:NSMakeSize(GetWidth(), GetHeight())] autorelease];
+    if(!nsimage)
+        return nil;
+    [nsimage addRepresentation: M_BITMAPDATA->m_cocoaNSBitmapImageRep];
+    if(useMask && GetMask())
+    {
+        // Show before/after to prove that the bitmap itself is not changed
+        // even though we just composited onto the NSImage
+        wxLogTrace(wxTRACE_COCOA,wxT("Before: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
+        NSImage *maskImage = [[NSImage alloc]
+                initWithSize:NSMakeSize(GetWidth(), GetHeight())];
+        [maskImage addRepresentation: GetMask()->GetNSBitmapImageRep()];
+        [nsimage lockFocus];
+        [maskImage compositeToPoint:NSZeroPoint operation:NSCompositeDestinationIn];
+        [nsimage unlockFocus];
+        [maskImage release];
+        wxLogTrace(wxTRACE_COCOA,wxT("After: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
+    }
+    return nsimage;
+}
+
 void wxBitmap::SetNSBitmapImageRep(WX_NSBitmapImageRep bitmapImageRep)
 {
     if(!M_BITMAPDATA)
@@ -272,7 +301,7 @@ bool wxBitmap::Create(int w, int h, int d)
             bytesPerRow: 0
             bitsPerPixel: 0];
 
-    wxLogDebug("M_BITMAPDATA=%p NSBitmapImageRep bitmapData=%p", M_BITMAPDATA, [M_BITMAPDATA->m_cocoaNSBitmapImageRep bitmapData]);
+    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_numColors = 0;
     M_BITMAPDATA->m_quality = 0;
@@ -338,8 +367,8 @@ wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
 
 wxImage wxBitmap::ConvertToImage() const
 {
-    if(!M_BITMAPDATA->m_ok)
-        return wxImage(5,5)/*wxNullImage*/;
+    if(!Ok())
+        return /*wxImage(5,5)*/wxNullImage;
     return wxImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
 }
 
@@ -392,10 +421,41 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
     M_BITMAPDATA->m_numColors = 0;
     M_BITMAPDATA->m_quality = 0;
     M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImage;
-    M_BITMAPDATA->m_bitmapMask = NULL;
+    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())
+        return NULL;
+
+    NSBitmapImageRep *bitmapRep = M_BITMAPDATA->m_cocoaNSBitmapImageRep;
+    if(!bitmapRep)
+        return NULL;
+
+    if([bitmapRep bitsPerPixel]!=bpp)
+    {
+        wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") );
+        return NULL;
+    }
+    data.m_width = [bitmapRep pixelsWide];
+    data.m_height = [bitmapRep pixelsHigh];
+    data.m_stride = [bitmapRep bytesPerRow];
+    return [bitmapRep bitmapData];
+
+    // NOTE: It is up to the user to make sure they used the proper
+    // pixel format class that details what is actually inside the pixels
+    // We can only check to make sure that the total number of bits per
+    // pixel are being iterated over properly
+    // NSBitmapImageRep can contain grayscale or CMYK data and
+    // wxPixelDataBase doesn't really define the color format
+}
+
+void wxBitmap::UngetRawData(wxPixelDataBase& data)
+{   // TODO
+}
+
 // ========================================================================
 // wxMask
 // ========================================================================
@@ -404,18 +464,14 @@ IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 
 wxMask::wxMask()
 {
-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_cocoaNSBitmapImageRep = nil;
 }
 
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 {
-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_cocoaNSBitmapImageRep = nil;
     Create(bitmap, colour);
 }
 
@@ -423,9 +479,7 @@ wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 {
-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_cocoaNSBitmapImageRep = nil;
 
     Create(bitmap, paletteIndex);
 }
@@ -433,16 +487,14 @@ wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 // Construct a mask from a mono bitmap (copies the bitmap).
 wxMask::wxMask(const wxBitmap& bitmap)
 {
-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_cocoaNSBitmapImageRep = nil;
 
     Create(bitmap);
 }
 
 wxMask::~wxMask()
 {
-// TODO: delete mask bitmap
+    [m_cocoaNSBitmapImageRep release];
 }
 
 // Create a mask from a mono bitmap (copies the bitmap).
@@ -460,11 +512,114 @@ bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
     return FALSE;
 }
 
+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"));
+    typename PixelData::Iterator p(srcData);
+    const int nRows = srcData.GetHeight();
+    const int nCols = srcData.GetWidth();
+    // Total number of bytes per destination column
+    const int dstRowLength = (nCols+7)/8;
+    // Number of source columns that fit into a byte in the destination
+    const int width_aligned = nCols/8*8;
+    for(int y=0; y<nRows; ++y)
+    {
+        typename PixelData::Iterator rowStart(p);
+        unsigned char *dstRow = dstData + y*dstRowLength;
+        for(int x=0; x<width_aligned; x+=8)
+        {
+            unsigned char *dstByte = dstRow + x/8;
+            *dstByte = 0;
+            // Take source RGB, compare it with the wxColour
+            for(int j=0; j<8; ++j, ++p)
+            {
+                *dstByte +=
+                (   p.Red()!=colour.Red()
+                ||  p.Green()!=colour.Green()
+                ||  p.Blue()!=colour.Blue()
+                )   << (7-j);
+            }
+        }
+        // Handle the remaining 0-7 pixels in the row
+        unsigned char *dstByte = dstRow + width_aligned/8;
+        if(nCols%8>0)
+            *dstByte = 0;
+        for(int j=0; j<(nCols%8); ++j, ++p)
+        {
+            *dstByte +=
+            (   p.Red()!=colour.Red()
+            ||  p.Green()!=colour.Green()
+            ||  p.Blue()!=colour.Blue()
+            )   << (7-j);
+        }
+        p = rowStart;
+        p.OffsetY(srcData,1);
+    }
+    return true;
+}
+
 // Create a mask from a bitmap and a colour indicating
 // the transparent area
 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 {
-// TODO
-    return FALSE;
+    wxAutoNSAutoreleasePool pool;
+    if(!bitmap.Ok())
+        return false;
+    int bmpWidth = bitmap.GetWidth();
+    int bmpHeight = bitmap.GetHeight();
+    int dstRowLength = (bmpWidth+7)/8;
+
+    // Create a bitmap image rep with 1-bit per pixel data representing
+    // the alpha channel padded such that rows end on byte boundaries
+    // Since NSBitmapImageRep doesn't have any sort of NSNullColorSpace
+    // we must have at least one channel of non-alpha data.  In order to
+    // make our life easy, we use planar data which results in two
+    // separate arrays.  We don't need to touch the first because it
+    // should never be used.  The second is the 1-bit "alpha" data.
+    NSBitmapImageRep *maskRep = [[[NSBitmapImageRep alloc]
+        initWithBitmapDataPlanes:NULL pixelsWide:bmpWidth
+        pixelsHigh:bmpHeight bitsPerSample:1
+        samplesPerPixel:2 hasAlpha:YES isPlanar:YES
+        colorSpaceName:NSCalibratedWhiteColorSpace
+        bytesPerRow:dstRowLength bitsPerPixel:1] autorelease];
+    wxCHECK(maskRep,false);
+
+    // We need the source NSBitmapImageRep to detemine its pixel format
+    NSBitmapImageRep *srcBitmapRep = const_cast<wxBitmap&>(bitmap).GetNSBitmapImageRep();
+    wxCHECK_MSG(srcBitmapRep,false,wxT("Can't create mask for an uninitialized bitmap"));
+
+    // Get a pointer to the destination data
+    unsigned char *dstPlanes[5] = {NULL,NULL,NULL,NULL,NULL};
+    [maskRep getBitmapDataPlanes:dstPlanes];
+    unsigned char *dstData = dstPlanes[1];
+    // The wxImage format (which we use whenever we imported from wxImage)
+    if([srcBitmapRep bitsPerPixel]==24 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
+    {
+        wxPixelData<wxBitmap,wxNativePixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
+        wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
+            false, wxT("Unable to access raw data"));
+    }
+    // 32-bpp RGBx (x=throw away, no alpha)
+    else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
+    {
+        typedef wxPixelFormat<unsigned char,32,0,1,2> PixelFormat;
+        wxPixelData<wxBitmap,PixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
+        wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
+            false, wxT("Unable to access raw data"));
+    }
+    // 32-bpp RGBA
+    else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==4 && [srcBitmapRep hasAlpha]==YES)
+    {
+        wxPixelData<wxBitmap,wxAlphaPixelFormat> 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];
+    return true;
 }