%}
-// 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
//---------------------------------------------------------------------------
+%{
+// 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>
* 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();
}
#endif
- bool Ok();
-
+ bool IsOk();
+ %pythoncode { Ok = IsOk }
+
DocDeclStr(
int , GetWidth(),
"Gets the width of the bitmap in pixels.", "");
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
#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
- %pythoncode { def __nonzero__(self): return self.Ok() }
+ %extend {
+ DocStr(CopyFromBuffer,
+ "Copy data from a RGB buffer object to replace the bitmap pixel data.
+See `wxBitmapFromBuffer` 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 `wxBitmapFromBufferRGBA` 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 {
- 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`");
+
};
// 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;
// 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`");
};
%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):
- 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`");
};
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 {
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);
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
+
+// Turn GIL acquisition back on.
%threadWrapperOn
projects / wxWidgets.git / blobdiff