[ 1718338 ] wxToolBarGTK: Implement tool right-click handling

[wxWidgets.git] / wxPython / src / _bitmap.i

diff --git a/wxPython/src/_bitmap.i b/wxPython/src/_bitmap.i
index d43ad7c762d2ca8f2705ea5d4daecf88f998fa91..994d5e93e8d1eb520b7306a30f1e806c3b59fabe 100644 (file)
--- a/wxPython/src/_bitmap.i
+++ b/wxPython/src/_bitmap.i
@@ -17,11 +17,28 @@
 %}
 
 
 %}
 
 

-// Turn off the aquisition of the Global Interpreter Lock for this file
+// Turn off the aquisition of the Global Interpreter Lock for the classes and
+// functions in this file

 %threadWrapperOff
 
 //---------------------------------------------------------------------------
 
 %threadWrapperOff
 
 //---------------------------------------------------------------------------
 

+%{
+// See http://tinyurl.com/e5adr for what premultiplying alpha means.  It
+// appears to me that the other platforms are already doing it, so I'll just
+// automatically do it for wxMSW here.
+#ifdef __WXMSW__
+#define wxPy_premultiply(p, a)   ((p) * (a) / 0xff)
+#define wxPy_unpremultiply(p, a) ((a) ? ((p) * 0xff / (a)) : (p))    
+#else
+#define wxPy_premultiply(p, a)   (p)
+#define wxPy_unpremultiply(p, a) (p)    
+#endif
+%}
+
+//---------------------------------------------------------------------------
+
+

 %{
 #include <wx/image.h>
     
 %{
 #include <wx/image.h>
     


@@ -108,8 +125,8 @@ public:
         * wx.BITMAP_TYPE_IFF
 
 :see: Alternate constructors `wx.EmptyBitmap`, `wx.BitmapFromIcon`,
         * wx.BITMAP_TYPE_IFF
 
 :see: Alternate constructors `wx.EmptyBitmap`, `wx.BitmapFromIcon`,

-      `wx.BitmapFromImage`, `wx.BitmapFromXPMData`,
-      `wx.BitmapFromBits`
+      `wx.BitmapFromImage`, `wx.BitmapFromXPMData`, `wx.BitmapFromBits`,
+      `wx.BitmapFromBuffer`, `wx.BitmapFromBufferRGBA`,

 ");
         
     ~wxBitmap();
 ");
         
     ~wxBitmap();


@@ -178,8 +195,9 @@ bit depths, the behaviour is platform dependent.", "",
     }
 #endif
 
     }
 #endif
 

-    bool Ok();
-    
+    bool IsOk();
+    %pythoncode { Ok = IsOk }
+

     DocDeclStr(
         int , GetWidth(),
         "Gets the width of the bitmap in pixels.", "");
     DocDeclStr(
         int , GetWidth(),
         "Gets the width of the bitmap in pixels.", "");


@@ -213,7 +231,6 @@ bitmap. This preserves mask information so that bitmaps and images can
 be converted back and forth without loss in that respect.", "");
     
 
 be converted back and forth without loss in that respect.", "");
     
 

-    

     DocDeclStr(
         virtual wxMask* , GetMask() const,
         "Gets the associated mask (if any) which may have been loaded from a
     DocDeclStr(
         virtual wxMask* , GetMask() const,
         "Gets the associated mask (if any) which may have been loaded from a


@@ -297,22 +314,97 @@ the ``type`` parameter.", "");
     
 #ifdef __WXMSW__
     bool CopyFromCursor(const wxCursor& cursor);
     
 #ifdef __WXMSW__
     bool CopyFromCursor(const wxCursor& cursor);

-
-// WXWIN_COMPATIBILITY_2_4
-  #if 0
-    int GetQuality();
-    void SetQuality(int q);
-    %pythoncode { GetQuality = wx._deprecated(GetQuality) }
-    %pythoncode { SetQuality = wx._deprecated(SetQuality) }
-  #endif

 #endif
 
 #endif
 

-    %pythoncode { def __nonzero__(self): return self.Ok() }
+    %extend {
+        DocStr(CopyFromBuffer,
+               "Copy data from a RGB buffer object to replace the bitmap pixel data.
+See `wx.BitmapFromBuffer` for more details.", "");
+        void CopyFromBuffer(buffer data, int DATASIZE)
+        {
+            int height=self->GetHeight();
+            int width=self->GetWidth();
+
+            if (DATASIZE != width * height * 3) {
+                wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
+            }
+            wxNativePixelData pixData(*self, wxPoint(0,0), wxSize(width, height));
+            if (! pixData) {
+                // raise an exception...
+                wxPyErr_SetString(PyExc_RuntimeError,
+                                  "Failed to gain raw access to bitmap data.");
+                return;
+            }
+
+            wxNativePixelData::Iterator p(pixData);
+            for (int y=0; y<height; y++) {
+                wxNativePixelData::Iterator rowStart = p;
+                for (int x=0; x<width; x++) {
+                    p.Red()   = *(data++);
+                    p.Green() = *(data++);
+                    p.Blue()  = *(data++);
+                    ++p;
+                }
+                p = rowStart;
+                p.OffsetY(pixData, 1);
+            }
+        }
+
+        DocStr(CopyFromBufferRGBA,
+               "Copy data from a RGBA buffer object to replace the bitmap pixel data.
+See `wx.BitmapFromBufferRGBA` for more details.", "");
+        void CopyFromBufferRGBA(buffer data, int DATASIZE)
+        {
+            int height=self->GetHeight();
+            int width=self->GetWidth();
+            
+            if (DATASIZE != width * height * 4) {
+                wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
+            }
+            wxAlphaPixelData pixData(*self, wxPoint(0,0), wxSize(width, height));
+            if (! pixData) {
+                // raise an exception...
+                wxPyErr_SetString(PyExc_RuntimeError,
+                                  "Failed to gain raw access to bitmap data.");
+                return;
+            }
+
+            pixData.UseAlpha();
+            wxAlphaPixelData::Iterator p(pixData);
+            for (int y=0; y<height; y++) {
+                wxAlphaPixelData::Iterator rowStart = p;
+                for (int x=0; x<width; x++) {
+                    byte a = data[3];
+                    p.Red()   = wxPy_premultiply(*(data++), a);
+                    p.Green() = wxPy_premultiply(*(data++), a);
+                    p.Blue()  = wxPy_premultiply(*(data++), a);
+                    p.Alpha() = a; data++;
+                    ++p;
+                }
+                p = rowStart;
+                p.OffsetY(pixData, 1);
+            }
+        }        
+    }

 
 

+    
+    %pythoncode { def __nonzero__(self): return self.IsOk() }
+
+    // TODO: Should these just be removed since the C++ operators are
+    // gone?  Or is using IsSameAs for wxPython ok?    

     %extend {
     %extend {

-        bool __eq__(const wxBitmap* other) { return other ? (*self == *other) : false; }
-        bool __ne__(const wxBitmap* other) { return other ? (*self != *other) : true;  }
+        bool __eq__(const wxBitmap* other) { return other ? self->IsSameAs(*other) : false; }
+        bool __ne__(const wxBitmap* other) { return other ? !self->IsSameAs(*other) : true;  }

     }
     }

+
+    %property(Depth, GetDepth, SetDepth, doc="See `GetDepth` and `SetDepth`");
+    %property(Height, GetHeight, SetHeight, doc="See `GetHeight` and `SetHeight`");
+    %property(Mask, GetMask, SetMask, doc="See `GetMask` and `SetMask`");
+    %property(Palette, GetPalette, doc="See `GetPalette`");
+    %property(Size, GetSize, SetSize, doc="See `GetSize` and `SetSize`");
+    %property(SubBitmap, GetSubBitmap, doc="See `GetSubBitmap`");
+    %property(Width, GetWidth, SetWidth, doc="See `GetWidth` and `SetWidth`");
+

 };
 
 
 };
 
 


@@ -321,19 +413,6 @@ the ``type`` parameter.", "");
 // use the Abstract Pixel API to be able to set RGB and A bytes directly into
 // the wxBitmap's pixel buffer.
 
 // use the Abstract Pixel API to be able to set RGB and A bytes directly into
 // the wxBitmap's pixel buffer.
 

-%{
-// See http://tinyurl.com/e5adr for what premultiplying alpha means.  It
-// appears to me that the other platforms are already doing it, so I'll just
-// automatically do it for wxMSW here.
-#ifdef __WXMSW__
-#define wxPy_premultiply(p, a)   ((p) * (a) / 256)
-#define wxPy_unpremultiply(p, a) ((a) ? ((p) * 256 / (a)) : (p))    
-#else
-#define wxPy_premultiply(p, a)   (p)
-#define wxPy_unpremultiply(p, a) (p)    
-#endif
-%}
-

 
 %newobject _BitmapFromBufferAlpha;
 %newobject _BitmapFromBuffer;
 
 %newobject _BitmapFromBufferAlpha;
 %newobject _BitmapFromBuffer;


@@ -524,6 +603,11 @@ public:
     // the distance between two rows
     int GetRowStride() const { return m_stride; }
 
     // the distance between two rows
     int GetRowStride() const { return m_stride; }
 

+    %property(Height, GetHeight, doc="See `GetHeight`");
+    %property(Origin, GetOrigin, doc="See `GetOrigin`");
+    %property(RowStride, GetRowStride, doc="See `GetRowStride`");
+    %property(Size, GetSize, doc="See `GetSize`");
+    %property(Width, GetWidth, doc="See `GetWidth`");

 };
 
 
 };
 
 


@@ -555,53 +639,42 @@ public:
 
     %pythoncode {
     def __iter__(self):
 
     %pythoncode {
     def __iter__(self):

-        """Create and return an iterator object for this pixel data object."""
-        return self.PixelIterator(self)
-
-    class PixelIterator(object):

         """
         """

-        Sequential iterator which returns pixel accessor objects starting at the
-        the top-left corner, and going row-by-row until the bottom-right
-        corner is reached.
+        Create and return an iterator object for this pixel data
+        object.  (It's really a generator but I won't tell if you
+        don't tell.)

         """
         """

-
-        class PixelAccessor(object):
-            """
-            This class is what is returned by the iterator and allows the pixel
-            to be Get or Set.
-            """
-            def __init__(self, data, pixels, x, y):
-                self.data = data
-                self.pixels = pixels
-                self.x = x
-                self.y = y
-            def Set(self, *args, **kw):
-                self.pixels.MoveTo(self.data, self.x, self.y)
-                return self.pixels.Set(*args, **kw)
+        width  = self.GetWidth()
+        height = self.GetHeight()
+        pixels = self.GetPixels()
+        
+        # This class is a facade over the pixels object (using the one
+        # in the enclosing scope) that only allows Get() and Set() to
+        # be called.
+        class PixelFacade(object):

             def Get(self):
             def Get(self):

-                self.pixels.MoveTo(self.data, self.x, self.y)
-                return self.pixels.Get()
-
-        def __init__(self, pixelData):
-            self.x = self.y = 0
-            self.w = pixelData.GetWidth()
-            self.h = pixelData.GetHeight()
-            self.data = pixelData
-            self.pixels = pixelData.GetPixels()
-
-        def __iter__(self):
-            return self
-
-        def next(self):
-            if self.y >= self.h:
-                raise StopIteration
-            p = self.PixelAccessor(self.data, self.pixels, self.x, self.y)
-            self.x += 1
-            if self.x >= self.w:
-                self.x = 0
-                self.y += 1
-            return p
+                return pixels.Get()
+            def Set(self, *args, **kw):
+                return pixels.Set(*args, **kw)
+            def __str__(self):
+                return str(self.Get())
+            def __repr__(self):
+                return 'pixel(%d,%d): %s' % (x,y,self.Get())
+            X = property(lambda self: x)
+            Y = property(lambda self: y)
+            
+        pf = PixelFacade()        
+        for y in xrange(height):
+            for x in xrange(width):
+                # We always generate the same pf instance, but it
+                # accesses the pixels object which we use to iterate
+                # over the pixel buffer.
+                yield pf    
+                pixels.nextPixel()
+            pixels.MoveTo(self, 0, y)

     }
     }

+
+    %property(Pixels, GetPixels, doc="See `GetPixels`");

 };
 
 
 };
 
 


@@ -630,10 +703,12 @@ public:
     void OffsetY(const PixelData& data, int y);
     void MoveTo(const PixelData& data, int x, int y);
 
     void OffsetY(const PixelData& data, int y);
     void MoveTo(const PixelData& data, int x, int y);
 

-// NOTE: For now I'm not wrapping the Red, Green, Blue and Alpha functions
-// because I can't hide the premultiplying needed on wxMSW if only the
-// individual components are wrapped.  Instead I've added the Set and Get
-// functions and put the premultiplying in there.
+// NOTE: For now I'm not wrapping the Red, Green, Blue and Alpha
+// functions because I can't hide the premultiplying needed on wxMSW
+// if only the individual components are wrapped, plus it would mean 3
+// or 4 trips per pixel from Python to C++ instead of just one.
+// Instead I've added the Set and Get functions and put the
+// premultiplying in there.

     
 //     %extend {
 //         byte _get_Red()   { return self->Red(); }
     
 //     %extend {
 //         byte _get_Red()   { return self->Red(); }


@@ -741,7 +816,7 @@ passed then BLACK is used.
     
     %extend {
         wxMask(const wxBitmap& bitmap, const wxColour& colour = wxNullColour) {
     
     %extend {
         wxMask(const wxBitmap& bitmap, const wxColour& colour = wxNullColour) {

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

                 return new wxMask(bitmap, *wxBLACK);
             else
                 return new wxMask(bitmap, colour);
                 return new wxMask(bitmap, *wxBLACK);
             else
                 return new wxMask(bitmap, colour);


@@ -755,4 +830,6 @@ passed then BLACK is used.
 
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
 
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------

+
+// Turn GIL acquisition back on.

 %threadWrapperOn
 %threadWrapperOn