Prevent accession of to-be-deleted mdi

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

diff --git a/src/cocoa/bitmap.mm b/src/cocoa/bitmap.mm
index 6e5702044de04602de73f8d8202174d2ea6abcc1..452a92cbeedf9564a0464c5f915f4fef049794ed 100644 (file)
--- a/src/cocoa/bitmap.mm
+++ b/src/cocoa/bitmap.mm
@@ -1,24 +1,27 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// 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
 // 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/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"
 #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
 #endif //WX_PRECOMP

-#include "wx/bitmap.h"
-#include "wx/image.h"
+

 #include "wx/xpmdecod.h"
 #include "wx/rawbmp.h"
 
 #include "wx/xpmdecod.h"
 #include "wx/rawbmp.h"
 


@@ -28,6 +31,9 @@
 #import <AppKit/NSBitmapImageRep.h>
 #import <AppKit/NSGraphics.h>
 #import <AppKit/NSImage.h>
 #import <AppKit/NSBitmapImageRep.h>
 #import <AppKit/NSGraphics.h>
 #import <AppKit/NSImage.h>

+#import <AppKit/NSColor.h>
+
+IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)

 
 // ========================================================================
 // wxBitmapRefData
 
 // ========================================================================
 // wxBitmapRefData


@@ -119,7 +125,7 @@ wxBitmap::wxBitmap(int w, int h, int d)
     (void)Create(w, h, d);
 }
 
     (void)Create(w, h, d);
 }
 

-wxBitmap::wxBitmap(void *data, wxBitmapType type, int width, int height, int depth)
+wxBitmap::wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth)

 {
     (void) Create(data, type, width, height, depth);
 }
 {
     (void) Create(data, type, width, height, depth);
 }


@@ -157,12 +163,17 @@ WX_NSImage wxBitmap::GetNSImage(bool useMask) const
     [nsimage addRepresentation: M_BITMAPDATA->m_cocoaNSBitmapImageRep];
     if(useMask && GetMask())
     {
     [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];
         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;
 }
     }
     return nsimage;
 }


@@ -233,7 +244,7 @@ void wxBitmap::SetMask(wxMask *mask)
     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 
     M_BITMAPDATA->m_bitmapMask = mask ;
 }
 

-bool wxBitmap::Ok() const
+bool wxBitmap::IsOk() const

 {
     return m_refData && M_BITMAPDATA->m_ok;
 }
 {
     return m_refData && M_BITMAPDATA->m_ok;
 }


@@ -293,10 +304,11 @@ bool wxBitmap::Create(int w, int h, int d)
             hasAlpha: NO
             isPlanar: NO
             colorSpaceName: NSCalibratedRGBColorSpace
             hasAlpha: NO
             isPlanar: NO
             colorSpaceName: NSCalibratedRGBColorSpace

-            bytesPerRow: 0
+            bytesPerRow: 0  // NOTE: Contrary to Apple documentation Mac OS
+                            // 10.4 will add padding bytes when 0 is used here

             bitsPerPixel: 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;
     M_BITMAPDATA->m_ok = true;
     M_BITMAPDATA->m_numColors = 0;
     M_BITMAPDATA->m_quality = 0;


@@ -336,7 +348,7 @@ bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
     return true;
 }
 
     return true;
 }
 

-bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)
+bool wxBitmap::Create(const void* data, wxBitmapType type, int width, int height, int depth)

 {
     UnRef();
 
 {
     UnRef();
 


@@ -350,9 +362,28 @@ bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPal
     return false;
 }
 
     return false;
 }
 

-bool wxBitmap::CopyFromIcon(const wxIcon& icno)
+bool wxBitmap::CopyFromIcon(const wxIcon& icon)

 {
 {

-    return false;
+    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];
+    [icon.GetNSImage() unlockFocus];
+    if(!newBitmapRep)
+        return false;
+    m_refData = new wxBitmapRefData;
+    M_BITMAPDATA->m_cocoaNSBitmapImageRep = 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;

 }
 
 wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
 }
 
 wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const


@@ -362,27 +393,26 @@ wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
 
 wxImage wxBitmap::ConvertToImage() const
 {
 
 wxImage wxBitmap::ConvertToImage() const
 {

-    if(!M_BITMAPDATA->m_ok)
-        return wxImage(5,5)/*wxNullImage*/;
-    return wxImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
-}
-
-bool wxBitmap::CreateFromXpm(const char **xpm)
-{
-#if wxUSE_IMAGE && wxUSE_XPM
-    UnRef();
-
-    wxCHECK_MSG( xpm, false, wxT("invalid XPM data") )
-
-    wxXPMDecoder decoder;
-    wxImage img = decoder.ReadData(xpm);
-    wxCHECK_MSG( img.Ok(), false, wxT("invalid XPM data") )
-
-    *this = wxBitmap(img);
-    return true;
-#else
-    return false;
-#endif
+    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)
 }
 
 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)


@@ -405,9 +435,11 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
             hasAlpha: NO
             isPlanar: NO
             colorSpaceName: NSCalibratedRGBColorSpace
             hasAlpha: NO
             isPlanar: NO
             colorSpaceName: NSCalibratedRGBColorSpace

-            bytesPerRow: 0
+            bytesPerRow: image.GetWidth()*3

             bitsPerPixel: 0];
 
             bitsPerPixel: 0];
 

+    // 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
     const int numBytes = image.GetWidth()*image.GetHeight()*3;
     memcpy([bitmapImage bitmapData], image.GetData(), numBytes);
     // TODO: Alpha and convert to desired depth


@@ -451,6 +483,10 @@ void wxBitmap::UngetRawData(wxPixelDataBase& data)
 {   // TODO
 }
 
 {   // TODO
 }
 

+void wxBitmap::UseAlpha()
+{   // TODO
+}
+

 // ========================================================================
 // wxMask
 // ========================================================================
 // ========================================================================
 // wxMask
 // ========================================================================


@@ -507,11 +543,11 @@ bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
     return FALSE;
 }
 
     return FALSE;
 }
 

-template <class PixelData>
+template <typename PixelData>

 static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colour, unsigned char *dstData)
 {
 static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colour, unsigned char *dstData)
 {

-    wxCHECK_MSG(dstData,false,"Couldn't access mask data");
-    class PixelData::Iterator p(srcData);
+    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 nRows = srcData.GetHeight();
     const int nCols = srcData.GetWidth();
     // Total number of bytes per destination column


@@ -520,7 +556,7 @@ static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colou
     const int width_aligned = nCols/8*8;
     for(int y=0; y<nRows; ++y)
     {
     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)
         {
         unsigned char *dstRow = dstData + y*dstRowLength;
         for(int x=0; x<width_aligned; x+=8)
         {


@@ -538,7 +574,8 @@ static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colou
         }
         // Handle the remaining 0-7 pixels in the row
         unsigned char *dstByte = dstRow + width_aligned/8;
         }
         // Handle the remaining 0-7 pixels in the row
         unsigned char *dstByte = dstRow + width_aligned/8;

-        *dstByte = 0;
+        if(nCols%8>0)
+            *dstByte = 0;

         for(int j=0; j<(nCols%8); ++j, ++p)
         {
             *dstByte +=
         for(int j=0; j<(nCols%8); ++j, ++p)
         {
             *dstByte +=


@@ -581,7 +618,7 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 
     // We need the source NSBitmapImageRep to detemine its pixel format
     NSBitmapImageRep *srcBitmapRep = const_cast<wxBitmap&>(bitmap).GetNSBitmapImageRep();
 
     // We need the source NSBitmapImageRep to detemine its pixel format
     NSBitmapImageRep *srcBitmapRep = const_cast<wxBitmap&>(bitmap).GetNSBitmapImageRep();

-    wxCHECK_MSG(srcBitmapRep,false,"Can't create mask for an uninitialized bitmap");
+    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};
 
     // Get a pointer to the destination data
     unsigned char *dstPlanes[5] = {NULL,NULL,NULL,NULL,NULL};


@@ -592,7 +629,7 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
     {
         wxPixelData<wxBitmap,wxNativePixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
         wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
     {
         wxPixelData<wxBitmap,wxNativePixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
         wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),

-            false, "Unable to access raw data");
+            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)
     }
     // 32-bpp RGBx (x=throw away, no alpha)
     else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)


@@ -600,20 +637,19 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
         typedef wxPixelFormat<unsigned char,32,0,1,2> PixelFormat;
         wxPixelData<wxBitmap,PixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
         wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
         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, "Unable to access raw data");
+            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),
     }
     // 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, "Unable to access raw data");
+            false, wxT("Unable to access raw data"));

     }
     else
     }
     else

-    {   wxCHECK_MSG(false,false,"Unimplemented pixel format"); }
+    {   wxCHECK_MSG(false,false,wxT("Unimplemented pixel format")); }

 
     // maskRep was autoreleased in case we had to exit quickly
     m_cocoaNSBitmapImageRep = [maskRep retain];
     return true;
 }
 
     // maskRep was autoreleased in case we had to exit quickly
     m_cocoaNSBitmapImageRep = [maskRep retain];
     return true;
 }

-