X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1d1972fce1db0ae559433967255ce486b0d7494a..074d2e0449453c9786f2a6431b4d48ceb429ca15:/wxPython/src/_bitmap.i diff --git a/wxPython/src/_bitmap.i b/wxPython/src/_bitmap.i index fcb37d0a41..f6ee5a0c8d 100644 --- a/wxPython/src/_bitmap.i +++ b/wxPython/src/_bitmap.i @@ -16,6 +16,10 @@ #include %} + +// Turn off the aquisition of the Global Interpreter Lock for this file +%threadWrapperOff + //--------------------------------------------------------------------------- %{ @@ -323,8 +327,10 @@ the ``type`` parameter.", ""); // 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 %} @@ -347,16 +353,16 @@ the ``type`` parameter.", ""); } wxBitmap* bmp = new wxBitmap(width, height, 32); - wxAlphaPixelData pixels(*bmp, wxPoint(0,0), wxSize(width,height)); - if (! pixels) { + wxAlphaPixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height)); + if (! pixData) { // raise an exception... wxPyErr_SetString(PyExc_RuntimeError, "Failed to gain raw access to bitmap data."); return NULL; } - pixels.UseAlpha(); - wxAlphaPixelData::Iterator p(pixels); + pixData.UseAlpha(); + wxAlphaPixelData::Iterator p(pixData); for (int y=0; yoperator bool(); } + } + + %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. + """ + + 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) + 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 + } +}; + + + +class PixelData##_Accessor +{ +public: + %nokwargs PixelData##_Accessor; + + PixelData##_Accessor(PixelData& data); + PixelData##_Accessor(wxBitmap& bmp, PixelData& data); + PixelData##_Accessor(); + + ~PixelData##_Accessor(); + + void Reset(const PixelData& data); + bool IsOk() const; + + %extend { + // PixelData##_Accessor& nextPixel() { return ++(*self); } + void nextPixel() { ++(*self); } + } + + void Offset(const PixelData& data, int x, int y); + void OffsetX(const PixelData& data, int x); + 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 puemultiplying in there. + +// %extend { +// byte _get_Red() { return self->Red(); } +// byte _get_Green() { return self->Green(); } +// byte _get_Blue() { return self->Blue(); } + +// void _set_Red(byte val) { self->Red() = val; } +// void _set_Green(byte val) { self->Green() = val; } +// void _set_Blue(byte val) { self->Blue() = val; } +// } + +// %pythoncode { +// Red = property(_get_Red, _set_Red) +// Green = property(_get_Green, _set_Green) +// Blue = property(_get_Blue, _set_Blue) +// } +}; +%enddef + + +%pythonAppend wxAlphaPixelData::wxAlphaPixelData "self.UseAlpha()" + +// Make the classes +PIXELDATA(wxNativePixelData) +PIXELDATA(wxAlphaPixelData) + + +// Add in a few things that are different between the wxNativePixelData and +// wxAlphaPixelData and the iterator classes and so are not included in our +// macro... + +%extend wxNativePixelData_Accessor { + void Set(byte red, byte green, byte blue) { + self->Red() = red; + self->Green() = green; + self->Blue() = blue; + } + + PyObject* Get() { + PyObject* rv = PyTuple_New(3); + PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red())); + PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green())); + PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue())); + return rv; + } +} + +%extend wxAlphaPixelData_Accessor { +// byte _get_Alpha() { return self->Alpha(); } +// void _set_Alpha(byte val) { self->Alpha() = val; } + +// %pythoncode { +// Alpha = property(_get_Alpha, _set_Alpha) +// } + + void Set(byte red, byte green, byte blue, byte alpha) { + self->Red() = wxPy_premultiply(red, alpha); + self->Green() = wxPy_premultiply(green, alpha); + self->Blue() = wxPy_premultiply(blue, alpha); + self->Alpha() = alpha; + } + + PyObject* Get() { + PyObject* rv = PyTuple_New(4); + int red = self->Red(); + int green = self->Green(); + int blue = self->Blue(); + int alpha = self->Alpha(); + + PyTuple_SetItem(rv, 0, PyInt_FromLong( wxPy_unpremultiply(red, alpha) )); + PyTuple_SetItem(rv, 1, PyInt_FromLong( wxPy_unpremultiply(green, alpha) )); + PyTuple_SetItem(rv, 2, PyInt_FromLong( wxPy_unpremultiply(blue, alpha) )); + PyTuple_SetItem(rv, 3, PyInt_FromLong( alpha )); + return rv; + } +} + + //--------------------------------------------------------------------------- DocStr(wxMask, @@ -548,3 +759,4 @@ passed then BLACK is used. //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- +%threadWrapperOn