X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/27e45892536c571947a72cef7f4bf77fe613c9ec..0a5bb138a71dfc1c706fc0858fb2801500e2c2e8:/wxPython/src/msw/_gdi.py diff --git a/wxPython/src/msw/_gdi.py b/wxPython/src/msw/_gdi.py index 7869a827b7..d46b6526a1 100644 --- a/wxPython/src/msw/_gdi.py +++ b/wxPython/src/msw/_gdi.py @@ -75,6 +75,8 @@ _gdi_.GDIObject_swigregister(GDIObject) C2S_NAME = _gdi_.C2S_NAME C2S_CSS_SYNTAX = _gdi_.C2S_CSS_SYNTAX C2S_HTML_SYNTAX = _gdi_.C2S_HTML_SYNTAX +ALPHA_TRANSPARENT = _gdi_.ALPHA_TRANSPARENT +ALPHA_OPAQUE = _gdi_.ALPHA_OPAQUE class Colour(_core.Object): """ A colour is an object representing a combination of Red, Green, and @@ -102,7 +104,7 @@ class Colour(_core.Object): __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ - __init__(self, byte red=0, byte green=0, byte blue=0) -> Colour + __init__(self, byte red=0, byte green=0, byte blue=0, byte alpha=ALPHA_OPAQUE) -> Colour Constructs a colour from red, green and blue values. @@ -136,18 +138,27 @@ class Colour(_core.Object): """ return _gdi_.Colour_Blue(*args, **kwargs) - def Ok(*args, **kwargs): + def Alpha(*args, **kwargs): """ - Ok(self) -> bool + Alpha(self) -> byte + + Returns the Alpha value. + """ + return _gdi_.Colour_Alpha(*args, **kwargs) + + def IsOk(*args, **kwargs): + """ + IsOk(self) -> bool Returns True if the colour object is valid (the colour has been initialised with RGB values). """ - return _gdi_.Colour_Ok(*args, **kwargs) + return _gdi_.Colour_IsOk(*args, **kwargs) + Ok = IsOk def Set(*args, **kwargs): """ - Set(self, byte red, byte green, byte blue) + Set(self, byte red, byte green, byte blue, byte alpha=ALPHA_OPAQUE) Sets the RGB intensity values. """ @@ -227,12 +238,16 @@ class Colour(_core.Object): return _gdi_.Colour_GetRGB(*args, **kwargs) asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead") - def __str__(self): return str(self.Get()) - def __repr__(self): return 'wx.Colour' + str(self.Get()) - def __nonzero__(self): return self.Ok() + def __str__(self): return str(self.Get(True)) + def __repr__(self): return 'wx.Colour' + str(self.Get(True)) + def __len__(self): return len(self.Get()) + def __getitem__(self, index): return self.Get()[index] + def __nonzero__(self): return self.IsOk() __safe_for_unpickling__ = True - def __reduce__(self): return (Colour, self.Get()) + def __reduce__(self): return (Colour, self.Get(True)) + Pixel = property(GetPixel,doc="See `GetPixel`") + RGB = property(GetRGB,SetRGB,doc="See `GetRGB` and `SetRGB`") _gdi_.Colour_swigregister(Colour) def NamedColour(*args, **kwargs): @@ -279,11 +294,13 @@ class Palette(GDIObject): """GetColoursCount(self) -> int""" return _gdi_.Palette_GetColoursCount(*args, **kwargs) - def Ok(*args, **kwargs): - """Ok(self) -> bool""" - return _gdi_.Palette_Ok(*args, **kwargs) + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.Palette_IsOk(*args, **kwargs) - def __nonzero__(self): return self.Ok() + Ok = IsOk + def __nonzero__(self): return self.IsOk() + ColoursCount = property(GetColoursCount,doc="See `GetColoursCount`") _gdi_.Palette_swigregister(Palette) #--------------------------------------------------------------------------- @@ -317,10 +334,11 @@ class Pen(GDIObject): """GetWidth(self) -> int""" return _gdi_.Pen_GetWidth(*args, **kwargs) - def Ok(*args, **kwargs): - """Ok(self) -> bool""" - return _gdi_.Pen_Ok(*args, **kwargs) + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.Pen_IsOk(*args, **kwargs) + Ok = IsOk def SetCap(*args, **kwargs): """SetCap(self, int cap_style)""" return _gdi_.Pen_SetCap(*args, **kwargs) @@ -363,6 +381,7 @@ class Pen(GDIObject): """GetDashCount(self) -> int""" return _gdi_.Pen_GetDashCount(*args, **kwargs) + DashCount = property(GetDashCount,doc="See `GetDashCount`") def GetStipple(*args, **kwargs): """GetStipple(self) -> Bitmap""" return _gdi_.Pen_GetStipple(*args, **kwargs) @@ -371,6 +390,7 @@ class Pen(GDIObject): """SetStipple(self, Bitmap stipple)""" return _gdi_.Pen_SetStipple(*args, **kwargs) + Stipple = property(GetStipple,SetStipple,doc="See `GetStipple` and `SetStipple`") def __eq__(*args, **kwargs): """__eq__(self, Pen other) -> bool""" return _gdi_.Pen___eq__(*args, **kwargs) @@ -379,7 +399,13 @@ class Pen(GDIObject): """__ne__(self, Pen other) -> bool""" return _gdi_.Pen___ne__(*args, **kwargs) - def __nonzero__(self): return self.Ok() + def __nonzero__(self): return self.IsOk() + Cap = property(GetCap,SetCap,doc="See `GetCap` and `SetCap`") + Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`") + Dashes = property(GetDashes,SetDashes,doc="See `GetDashes` and `SetDashes`") + Join = property(GetJoin,SetJoin,doc="See `GetJoin` and `SetJoin`") + Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`") + Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`") _gdi_.Pen_swigregister(Pen) #--------------------------------------------------------------------------- @@ -460,15 +486,19 @@ class Brush(GDIObject): """ return _gdi_.Brush_IsHatch(*args, **kwargs) - def Ok(*args, **kwargs): + def IsOk(*args, **kwargs): """ - Ok(self) -> bool + IsOk(self) -> bool Returns True if the brush is initialised and valid. """ - return _gdi_.Brush_Ok(*args, **kwargs) + return _gdi_.Brush_IsOk(*args, **kwargs) - def __nonzero__(self): return self.Ok() + Ok = IsOk + def __nonzero__(self): return self.IsOk() + Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`") + Stipple = property(GetStipple,SetStipple,doc="See `GetStipple` and `SetStipple`") + Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`") _gdi_.Brush_swigregister(Brush) def BrushFromBitmap(*args, **kwargs): @@ -508,10 +538,11 @@ class Bitmap(GDIObject): """SetHandle(self, long handle)""" return _gdi_.Bitmap_SetHandle(*args, **kwargs) - def Ok(*args, **kwargs): - """Ok(self) -> bool""" - return _gdi_.Bitmap_Ok(*args, **kwargs) + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.Bitmap_IsOk(*args, **kwargs) + Ok = IsOk def GetWidth(*args, **kwargs): """ GetWidth(self) -> int @@ -662,7 +693,25 @@ class Bitmap(GDIObject): """CopyFromCursor(self, Cursor cursor) -> bool""" return _gdi_.Bitmap_CopyFromCursor(*args, **kwargs) - def __nonzero__(self): return self.Ok() + def CopyFromBuffer(*args, **kwargs): + """ + CopyFromBuffer(self, buffer data) + + Copy data from a RGB buffer object to replace the bitmap pixel data. + See `wxBitmapFromBuffer` for more . + """ + return _gdi_.Bitmap_CopyFromBuffer(*args, **kwargs) + + def CopyFromBufferRGBA(*args, **kwargs): + """ + CopyFromBufferRGBA(self, buffer data) + + Copy data from a RGBA buffer object to replace the bitmap pixel data. + See `wxBitmapFromBufferRGBA` for more . + """ + return _gdi_.Bitmap_CopyFromBufferRGBA(*args, **kwargs) + + def __nonzero__(self): return self.IsOk() def __eq__(*args, **kwargs): """__eq__(self, Bitmap other) -> bool""" return _gdi_.Bitmap___eq__(*args, **kwargs) @@ -671,6 +720,13 @@ class Bitmap(GDIObject): """__ne__(self, Bitmap other) -> bool""" return _gdi_.Bitmap___ne__(*args, **kwargs) + Depth = property(GetDepth,SetDepth,doc="See `GetDepth` and `SetDepth`") + Height = property(GetHeight,SetHeight,doc="See `GetHeight` and `SetHeight`") + Mask = property(GetMask,SetMask,doc="See `GetMask` and `SetMask`") + Palette = property(GetPalette,doc="See `GetPalette`") + Size = property(GetSize,SetSize,doc="See `GetSize` and `SetSize`") + SubBitmap = property(GetSubBitmap,doc="See `GetSubBitmap`") + Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`") _gdi_.Bitmap_swigregister(Bitmap) def EmptyBitmap(*args, **kwargs): @@ -727,6 +783,331 @@ def BitmapFromBits(*args, **kwargs): val = _gdi_.new_BitmapFromBits(*args, **kwargs) return val + +def _BitmapFromBufferAlpha(*args, **kwargs): + """_BitmapFromBufferAlpha(int width, int height, buffer data, buffer alpha) -> Bitmap""" + return _gdi_._BitmapFromBufferAlpha(*args, **kwargs) + +def _BitmapFromBuffer(*args, **kwargs): + """_BitmapFromBuffer(int width, int height, buffer data) -> Bitmap""" + return _gdi_._BitmapFromBuffer(*args, **kwargs) +def BitmapFromBuffer(width, height, dataBuffer, alphaBuffer=None): + """ + Creates a `wx.Bitmap` from the data in dataBuffer. The dataBuffer + parameter must be a Python object that implements the buffer + interface, such as a string, array, etc. The dataBuffer object is + expected to contain a series of RGB bytes and be width*height*3 + bytes long. A buffer object can optionally be supplied for the + image's alpha channel data, and it is expected to be width*height + bytes long. On Windows the RGB values are 'premultiplied' by the + alpha values. (The other platforms do the multiplication + themselves.) + + Unlike `wx.ImageFromBuffer` the bitmap created with this function + does not share the memory buffer with the buffer object. This is + because the native pixel buffer format varies on different + platforms, and so instead an efficient as possible copy of the + data is made from the buffer objects to the bitmap's native pixel + buffer. For direct access to a bitmap's pixel buffer see + `wx.NativePixelData` and `wx.AlphaPixelData`. + + :see: `wx.Bitmap`, `wx.BitmapFromBufferRGBA`, `wx.NativePixelData`, + `wx.AlphaPixelData`, `wx.ImageFromBuffer` + """ + if alphaBuffer is not None: + return _gdi_._BitmapFromBufferAlpha(width, height, dataBuffer, alphaBuffer) + else: + return _gdi_._BitmapFromBuffer(width, height, dataBuffer) + + +def _BitmapFromBufferRGBA(*args, **kwargs): + """_BitmapFromBufferRGBA(int width, int height, buffer data) -> Bitmap""" + return _gdi_._BitmapFromBufferRGBA(*args, **kwargs) +def BitmapFromBufferRGBA(width, height, dataBuffer): + """ + Creates a `wx.Bitmap` from the data in dataBuffer. The dataBuffer + parameter must be a Python object that implements the buffer + interface, such as a string, array, etc. The dataBuffer object is + expected to contain a series of RGBA bytes (red, green, blue and + alpha) and be width*height*4 bytes long. On Windows the RGB + values are 'premultiplied' by the alpha values. (The other + platforms do the multiplication themselves.) + + Unlike `wx.ImageFromBuffer` the bitmap created with this function + does not share the memory buffer with the buffer object. This is + because the native pixel buffer format varies on different + platforms, and so instead an efficient as possible copy of the + data is made from the buffer object to the bitmap's native pixel + buffer. For direct access to a bitmap's pixel buffer see + `wx.NativePixelData` and `wx.AlphaPixelData`. + + :see: `wx.Bitmap`, `wx.BitmapFromBuffer`, `wx.NativePixelData`, + `wx.AlphaPixelData`, `wx.ImageFromBuffer` + """ + return _gdi_._BitmapFromBufferRGBA(width, height, dataBuffer) + +class PixelDataBase(object): + """Proxy of C++ PixelDataBase class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self): raise AttributeError, "No constructor defined" + __repr__ = _swig_repr + def GetOrigin(*args, **kwargs): + """GetOrigin(self) -> Point""" + return _gdi_.PixelDataBase_GetOrigin(*args, **kwargs) + + def GetWidth(*args, **kwargs): + """GetWidth(self) -> int""" + return _gdi_.PixelDataBase_GetWidth(*args, **kwargs) + + def GetHeight(*args, **kwargs): + """GetHeight(self) -> int""" + return _gdi_.PixelDataBase_GetHeight(*args, **kwargs) + + def GetSize(*args, **kwargs): + """GetSize(self) -> Size""" + return _gdi_.PixelDataBase_GetSize(*args, **kwargs) + + def GetRowStride(*args, **kwargs): + """GetRowStride(self) -> int""" + return _gdi_.PixelDataBase_GetRowStride(*args, **kwargs) + + Height = property(GetHeight,doc="See `GetHeight`") + Origin = property(GetOrigin,doc="See `GetOrigin`") + RowStride = property(GetRowStride,doc="See `GetRowStride`") + Size = property(GetSize,doc="See `GetSize`") + Width = property(GetWidth,doc="See `GetWidth`") +_gdi_.PixelDataBase_swigregister(PixelDataBase) + +class NativePixelData(PixelDataBase): + """Proxy of C++ NativePixelData class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(self, Bitmap bmp) -> NativePixelData + __init__(self, Bitmap bmp, Rect rect) -> NativePixelData + __init__(self, Bitmap bmp, Point pt, Size sz) -> NativePixelData + """ + _gdi_.NativePixelData_swiginit(self,_gdi_.new_NativePixelData(*args)) + __swig_destroy__ = _gdi_.delete_NativePixelData + __del__ = lambda self : None; + def GetPixels(*args, **kwargs): + """GetPixels(self) -> NativePixelData_Accessor""" + return _gdi_.NativePixelData_GetPixels(*args, **kwargs) + + def UseAlpha(*args, **kwargs): + """UseAlpha(self)""" + return _gdi_.NativePixelData_UseAlpha(*args, **kwargs) + + def __nonzero__(*args, **kwargs): + """__nonzero__(self) -> bool""" + return _gdi_.NativePixelData___nonzero__(*args, **kwargs) + + def __iter__(self): + """ + 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.) + """ + width = self.GetWidth() + height = self.GetHeight() + pixels = self.GetPixels() + + + + + class PixelFacade(object): + def Get(self): + 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): + + + + yield pf + pixels.nextPixel() + pixels.MoveTo(self, 0, y) + + Pixels = property(GetPixels,doc="See `GetPixels`") +_gdi_.NativePixelData_swigregister(NativePixelData) + +class NativePixelData_Accessor(object): + """Proxy of C++ NativePixelData_Accessor class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(self, NativePixelData data) -> NativePixelData_Accessor + __init__(self, Bitmap bmp, NativePixelData data) -> NativePixelData_Accessor + __init__(self) -> NativePixelData_Accessor + """ + _gdi_.NativePixelData_Accessor_swiginit(self,_gdi_.new_NativePixelData_Accessor(*args)) + __swig_destroy__ = _gdi_.delete_NativePixelData_Accessor + __del__ = lambda self : None; + def Reset(*args, **kwargs): + """Reset(self, NativePixelData data)""" + return _gdi_.NativePixelData_Accessor_Reset(*args, **kwargs) + + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.NativePixelData_Accessor_IsOk(*args, **kwargs) + + def nextPixel(*args, **kwargs): + """nextPixel(self)""" + return _gdi_.NativePixelData_Accessor_nextPixel(*args, **kwargs) + + def Offset(*args, **kwargs): + """Offset(self, NativePixelData data, int x, int y)""" + return _gdi_.NativePixelData_Accessor_Offset(*args, **kwargs) + + def OffsetX(*args, **kwargs): + """OffsetX(self, NativePixelData data, int x)""" + return _gdi_.NativePixelData_Accessor_OffsetX(*args, **kwargs) + + def OffsetY(*args, **kwargs): + """OffsetY(self, NativePixelData data, int y)""" + return _gdi_.NativePixelData_Accessor_OffsetY(*args, **kwargs) + + def MoveTo(*args, **kwargs): + """MoveTo(self, NativePixelData data, int x, int y)""" + return _gdi_.NativePixelData_Accessor_MoveTo(*args, **kwargs) + + def Set(*args, **kwargs): + """Set(self, byte red, byte green, byte blue)""" + return _gdi_.NativePixelData_Accessor_Set(*args, **kwargs) + + def Get(*args, **kwargs): + """Get(self) -> PyObject""" + return _gdi_.NativePixelData_Accessor_Get(*args, **kwargs) + +_gdi_.NativePixelData_Accessor_swigregister(NativePixelData_Accessor) + +class AlphaPixelData(PixelDataBase): + """Proxy of C++ AlphaPixelData class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(self, Bitmap bmp) -> AlphaPixelData + __init__(self, Bitmap bmp, Rect rect) -> AlphaPixelData + __init__(self, Bitmap bmp, Point pt, Size sz) -> AlphaPixelData + """ + _gdi_.AlphaPixelData_swiginit(self,_gdi_.new_AlphaPixelData(*args)) + self.UseAlpha() + + __swig_destroy__ = _gdi_.delete_AlphaPixelData + __del__ = lambda self : None; + def GetPixels(*args, **kwargs): + """GetPixels(self) -> AlphaPixelData_Accessor""" + return _gdi_.AlphaPixelData_GetPixels(*args, **kwargs) + + def UseAlpha(*args, **kwargs): + """UseAlpha(self)""" + return _gdi_.AlphaPixelData_UseAlpha(*args, **kwargs) + + def __nonzero__(*args, **kwargs): + """__nonzero__(self) -> bool""" + return _gdi_.AlphaPixelData___nonzero__(*args, **kwargs) + + def __iter__(self): + """ + 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.) + """ + width = self.GetWidth() + height = self.GetHeight() + pixels = self.GetPixels() + + + + + class PixelFacade(object): + def Get(self): + 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): + + + + yield pf + pixels.nextPixel() + pixels.MoveTo(self, 0, y) + + Pixels = property(GetPixels,doc="See `GetPixels`") +_gdi_.AlphaPixelData_swigregister(AlphaPixelData) + +class AlphaPixelData_Accessor(object): + """Proxy of C++ AlphaPixelData_Accessor class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(self, AlphaPixelData data) -> AlphaPixelData_Accessor + __init__(self, Bitmap bmp, AlphaPixelData data) -> AlphaPixelData_Accessor + __init__(self) -> AlphaPixelData_Accessor + """ + _gdi_.AlphaPixelData_Accessor_swiginit(self,_gdi_.new_AlphaPixelData_Accessor(*args)) + __swig_destroy__ = _gdi_.delete_AlphaPixelData_Accessor + __del__ = lambda self : None; + def Reset(*args, **kwargs): + """Reset(self, AlphaPixelData data)""" + return _gdi_.AlphaPixelData_Accessor_Reset(*args, **kwargs) + + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.AlphaPixelData_Accessor_IsOk(*args, **kwargs) + + def nextPixel(*args, **kwargs): + """nextPixel(self)""" + return _gdi_.AlphaPixelData_Accessor_nextPixel(*args, **kwargs) + + def Offset(*args, **kwargs): + """Offset(self, AlphaPixelData data, int x, int y)""" + return _gdi_.AlphaPixelData_Accessor_Offset(*args, **kwargs) + + def OffsetX(*args, **kwargs): + """OffsetX(self, AlphaPixelData data, int x)""" + return _gdi_.AlphaPixelData_Accessor_OffsetX(*args, **kwargs) + + def OffsetY(*args, **kwargs): + """OffsetY(self, AlphaPixelData data, int y)""" + return _gdi_.AlphaPixelData_Accessor_OffsetY(*args, **kwargs) + + def MoveTo(*args, **kwargs): + """MoveTo(self, AlphaPixelData data, int x, int y)""" + return _gdi_.AlphaPixelData_Accessor_MoveTo(*args, **kwargs) + + def Set(*args, **kwargs): + """Set(self, byte red, byte green, byte blue, byte alpha)""" + return _gdi_.AlphaPixelData_Accessor_Set(*args, **kwargs) + + def Get(*args, **kwargs): + """Get(self) -> PyObject""" + return _gdi_.AlphaPixelData_Accessor_Get(*args, **kwargs) + +_gdi_.AlphaPixelData_Accessor_swigregister(AlphaPixelData_Accessor) + class Mask(_core.Object): """ This class encapsulates a monochrome mask bitmap, where the masked @@ -780,10 +1161,11 @@ class Icon(GDIObject): """SetHandle(self, long handle)""" return _gdi_.Icon_SetHandle(*args, **kwargs) - def Ok(*args, **kwargs): - """Ok(self) -> bool""" - return _gdi_.Icon_Ok(*args, **kwargs) + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.Icon_IsOk(*args, **kwargs) + Ok = IsOk def GetWidth(*args, **kwargs): """GetWidth(self) -> int""" return _gdi_.Icon_GetWidth(*args, **kwargs) @@ -816,7 +1198,10 @@ class Icon(GDIObject): """CopyFromBitmap(self, Bitmap bmp)""" return _gdi_.Icon_CopyFromBitmap(*args, **kwargs) - def __nonzero__(self): return self.Ok() + def __nonzero__(self): return self.IsOk() + Depth = property(GetDepth,SetDepth,doc="See `GetDepth` and `SetDepth`") + Height = property(GetHeight,SetHeight,doc="See `GetHeight` and `SetHeight`") + Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`") _gdi_.Icon_swigregister(Icon) def EmptyIcon(*args, **kwargs): @@ -852,7 +1237,7 @@ class IconLocation(object): """IsOk(self) -> bool""" return _gdi_.IconLocation_IsOk(*args, **kwargs) - def __nonzero__(self): return self.Ok() + def __nonzero__(self): return self.IsOk() def SetFileName(*args, **kwargs): """SetFileName(self, String filename)""" return _gdi_.IconLocation_SetFileName(*args, **kwargs) @@ -869,6 +1254,8 @@ class IconLocation(object): """GetIndex(self) -> int""" return _gdi_.IconLocation_GetIndex(*args, **kwargs) + FileName = property(GetFileName,SetFileName,doc="See `GetFileName` and `SetFileName`") + Index = property(GetIndex,SetIndex,doc="See `GetIndex` and `SetIndex`") _gdi_.IconLocation_swigregister(IconLocation) class IconBundle(object): @@ -892,6 +1279,7 @@ class IconBundle(object): """GetIcon(self, Size size) -> Icon""" return _gdi_.IconBundle_GetIcon(*args, **kwargs) + Icon = property(GetIcon,doc="See `GetIcon`") _gdi_.IconBundle_swigregister(IconBundle) def IconBundleFromFile(*args, **kwargs): @@ -945,11 +1333,12 @@ class Cursor(GDIObject): """ return _gdi_.Cursor_SetHandle(*args, **kwargs) - def Ok(*args, **kwargs): - """Ok(self) -> bool""" - return _gdi_.Cursor_Ok(*args, **kwargs) + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.Cursor_IsOk(*args, **kwargs) - def __nonzero__(self): return self.Ok() + Ok = IsOk + def __nonzero__(self): return self.IsOk() def GetWidth(*args, **kwargs): """GetWidth(self) -> int""" return _gdi_.Cursor_GetWidth(*args, **kwargs) @@ -1058,6 +1447,10 @@ class Region(GDIObject): """IsEmpty(self) -> bool""" return _gdi_.Region_IsEmpty(*args, **kwargs) + def IsEqual(*args, **kwargs): + """IsEqual(self, Region region) -> bool""" + return _gdi_.Region_IsEqual(*args, **kwargs) + def Union(*args, **kwargs): """Union(self, int x, int y, int width, int height) -> bool""" return _gdi_.Region_Union(*args, **kwargs) @@ -1106,6 +1499,7 @@ class Region(GDIObject): """UnionBitmapColour(self, Bitmap bmp, Colour transColour, int tolerance=0) -> bool""" return _gdi_.Region_UnionBitmapColour(*args, **kwargs) + Box = property(GetBox,doc="See `GetBox`") _gdi_.Region_swigregister(Region) def RegionFromBitmap(*args, **kwargs): @@ -1176,6 +1570,13 @@ class RegionIterator(_core.Object): """__nonzero__(self) -> bool""" return _gdi_.RegionIterator___nonzero__(*args, **kwargs) + H = property(GetH,doc="See `GetH`") + Height = property(GetHeight,doc="See `GetHeight`") + Rect = property(GetRect,doc="See `GetRect`") + W = property(GetW,doc="See `GetW`") + Width = property(GetWidth,doc="See `GetWidth`") + X = property(GetX,doc="See `GetX`") + Y = property(GetY,doc="See `GetY`") _gdi_.RegionIterator_swigregister(RegionIterator) #--------------------------------------------------------------------------- @@ -1407,6 +1808,13 @@ class NativeFontInfo(object): """ToUserString(self) -> String""" return _gdi_.NativeFontInfo_ToUserString(*args, **kwargs) + Encoding = property(GetEncoding,SetEncoding,doc="See `GetEncoding` and `SetEncoding`") + FaceName = property(GetFaceName,SetFaceName,doc="See `GetFaceName` and `SetFaceName`") + Family = property(GetFamily,SetFamily,doc="See `GetFamily` and `SetFamily`") + PointSize = property(GetPointSize,SetPointSize,doc="See `GetPointSize` and `SetPointSize`") + Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`") + Underlined = property(GetUnderlined,SetUnderlined,doc="See `GetUnderlined` and `SetUnderlined`") + Weight = property(GetWeight,SetWeight,doc="See `GetWeight` and `SetWeight`") _gdi_.NativeFontInfo_swigregister(NativeFontInfo) class NativeEncodingInfo(object): @@ -1513,6 +1921,7 @@ class FontMapper(object): """SetDialogTitle(self, String title)""" return _gdi_.FontMapper_SetDialogTitle(*args, **kwargs) + AltForEncoding = property(GetAltForEncoding,doc="See `GetAltForEncoding`") _gdi_.FontMapper_swigregister(FontMapper) def FontMapper_Get(*args): @@ -1598,15 +2007,16 @@ class Font(GDIObject): _gdi_.Font_swiginit(self,_gdi_.new_Font(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_Font __del__ = lambda self : None; - def Ok(*args, **kwargs): + def IsOk(*args, **kwargs): """ - Ok(self) -> bool + IsOk(self) -> bool Returns ``True`` if this font was successfully created. """ - return _gdi_.Font_Ok(*args, **kwargs) + return _gdi_.Font_IsOk(*args, **kwargs) - def __nonzero__(self): return self.Ok() + Ok = IsOk + def __nonzero__(self): return self.IsOk() def __eq__(*args, **kwargs): """__eq__(self, Font other) -> bool""" return _gdi_.Font___eq__(*args, **kwargs) @@ -1873,6 +2283,21 @@ class Font(GDIObject): return _gdi_.Font_SetDefaultEncoding(*args, **kwargs) SetDefaultEncoding = staticmethod(SetDefaultEncoding) + Encoding = property(GetEncoding,SetEncoding,doc="See `GetEncoding` and `SetEncoding`") + FaceName = property(GetFaceName,SetFaceName,doc="See `GetFaceName` and `SetFaceName`") + Family = property(GetFamily,SetFamily,doc="See `GetFamily` and `SetFamily`") + FamilyString = property(GetFamilyString,doc="See `GetFamilyString`") + NativeFontInfo = property(GetNativeFontInfo,SetNativeFontInfo,doc="See `GetNativeFontInfo` and `SetNativeFontInfo`") + NativeFontInfoDesc = property(GetNativeFontInfoDesc,doc="See `GetNativeFontInfoDesc`") + NativeFontInfoUserDesc = property(GetNativeFontInfoUserDesc,SetNativeFontInfoUserDesc,doc="See `GetNativeFontInfoUserDesc` and `SetNativeFontInfoUserDesc`") + NoAntiAliasing = property(GetNoAntiAliasing,SetNoAntiAliasing,doc="See `GetNoAntiAliasing` and `SetNoAntiAliasing`") + PixelSize = property(GetPixelSize,SetPixelSize,doc="See `GetPixelSize` and `SetPixelSize`") + PointSize = property(GetPointSize,SetPointSize,doc="See `GetPointSize` and `SetPointSize`") + Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`") + StyleString = property(GetStyleString,doc="See `GetStyleString`") + Underlined = property(GetUnderlined,SetUnderlined,doc="See `GetUnderlined` and `SetUnderlined`") + Weight = property(GetWeight,SetWeight,doc="See `GetWeight` and `SetWeight`") + WeightString = property(GetWeightString,doc="See `GetWeightString`") _gdi_.Font_swigregister(Font) def FontFromNativeInfo(*args, **kwargs): @@ -1981,12 +2406,12 @@ class FontEnumerator(object): def __init__(self, *args, **kwargs): """__init__(self) -> FontEnumerator""" _gdi_.FontEnumerator_swiginit(self,_gdi_.new_FontEnumerator(*args, **kwargs)) - self._setCallbackInfo(self, FontEnumerator, 0) + FontEnumerator._setCallbackInfo(self, self, FontEnumerator) __swig_destroy__ = _gdi_.delete_FontEnumerator __del__ = lambda self : None; def _setCallbackInfo(*args, **kwargs): - """_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)""" + """_setCallbackInfo(self, PyObject self, PyObject _class, int incref=0)""" return _gdi_.FontEnumerator__setCallbackInfo(*args, **kwargs) def EnumerateFacenames(*args, **kwargs): @@ -2360,6 +2785,11 @@ class Locale(object): """AddCatalog(self, String szDomain) -> bool""" return _gdi_.Locale_AddCatalog(*args, **kwargs) + def IsAvailable(*args, **kwargs): + """IsAvailable(int lang) -> bool""" + return _gdi_.Locale_IsAvailable(*args, **kwargs) + + IsAvailable = staticmethod(IsAvailable) def IsLoaded(*args, **kwargs): """IsLoaded(self, String szDomain) -> bool""" return _gdi_.Locale_IsLoaded(*args, **kwargs) @@ -2392,6 +2822,12 @@ class Locale(object): """GetName(self) -> String""" return _gdi_.Locale_GetName(*args, **kwargs) + CanonicalName = property(GetCanonicalName,doc="See `GetCanonicalName`") + Language = property(GetLanguage,doc="See `GetLanguage`") + Locale = property(GetLocale,doc="See `GetLocale`") + Name = property(GetName,doc="See `GetName`") + String = property(GetString,doc="See `GetString`") + SysName = property(GetSysName,doc="See `GetSysName`") _gdi_.Locale_swigregister(Locale) def Locale_GetSystemLanguage(*args): @@ -2410,6 +2846,10 @@ def Locale_AddCatalogLookupPathPrefix(*args, **kwargs): """Locale_AddCatalogLookupPathPrefix(String prefix)""" return _gdi_.Locale_AddCatalogLookupPathPrefix(*args, **kwargs) +def Locale_IsAvailable(*args, **kwargs): + """Locale_IsAvailable(int lang) -> bool""" + return _gdi_.Locale_IsAvailable(*args, **kwargs) + def Locale_GetLanguageInfo(*args, **kwargs): """Locale_GetLanguageInfo(int lang) -> LanguageInfo""" return _gdi_.Locale_GetLanguageInfo(*args, **kwargs) @@ -2426,6 +2866,34 @@ def Locale_AddLanguage(*args, **kwargs): """Locale_AddLanguage(LanguageInfo info)""" return _gdi_.Locale_AddLanguage(*args, **kwargs) +class PyLocale(Locale): + """Proxy of C++ PyLocale class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self, int language=-1, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> PyLocale""" + _gdi_.PyLocale_swiginit(self,_gdi_.new_PyLocale(*args, **kwargs)) + PyLocale._setCallbackInfo(self, self, PyLocale) + + __swig_destroy__ = _gdi_.delete_PyLocale + __del__ = lambda self : None; + def _setCallbackInfo(*args, **kwargs): + """_setCallbackInfo(self, PyObject self, PyObject _class)""" + return _gdi_.PyLocale__setCallbackInfo(*args, **kwargs) + + def GetSingularString(*args, **kwargs): + """GetSingularString(self, wxChar szOrigString, wxChar szDomain=None) -> wxChar""" + return _gdi_.PyLocale_GetSingularString(*args, **kwargs) + + def GetPluralString(*args, **kwargs): + """ + GetPluralString(self, wxChar szOrigString, wxChar szOrigString2, size_t n, + wxChar szDomain=None) -> wxChar + """ + return _gdi_.PyLocale_GetPluralString(*args, **kwargs) + +_gdi_.PyLocale_swigregister(PyLocale) + def GetLocale(*args): """GetLocale() -> Locale""" @@ -2477,7 +2945,9 @@ _gdi_.EncodingConverter_swigregister(EncodingConverter) def GetTranslation(*args): """ GetTranslation(String str) -> String + GetTranslation(String str, String domain) -> String GetTranslation(String str, String strPlural, size_t n) -> String + GetTranslation(String str, String strPlural, size_t n, String domain) -> String """ return _gdi_.GetTranslation(*args) @@ -3004,6 +3474,10 @@ class DC(_core.Object): """ return _gdi_.DC_BlitPointSize(*args, **kwargs) + def GetAsBitmap(*args, **kwargs): + """GetAsBitmap(self, Rect subrect=None) -> Bitmap""" + return _gdi_.DC_GetAsBitmap(*args, **kwargs) + def SetClippingRegion(*args, **kwargs): """ SetClippingRegion(self, int x, int y, int width, int height) @@ -3296,9 +3770,9 @@ class DC(_core.Object): def GetMultiLineTextExtent(*args, **kwargs): """ GetMultiLineTextExtent(wxString string, Font font=None) -> - (width, height, descent, externalLeading) + (width, height, lineHeight) - Get the width, height, decent and leading of the text using the + Get the width, height, and line height of the text using the current or specified font. Works for single as well as multi-line strings. """ @@ -3469,14 +3943,15 @@ class DC(_core.Object): """ return _gdi_.DC_GetPPI(*args, **kwargs) - def Ok(*args, **kwargs): + def IsOk(*args, **kwargs): """ - Ok(self) -> bool + IsOk(self) -> bool Returns true if the DC is ok to use. """ - return _gdi_.DC_Ok(*args, **kwargs) + return _gdi_.DC_IsOk(*args, **kwargs) + Ok = IsOk def GetBackgroundMode(*args, **kwargs): """ GetBackgroundMode(self) -> int @@ -3779,7 +4254,27 @@ class DC(_core.Object): """ return _gdi_.DC_GetBoundingBox(*args, **kwargs) - def __nonzero__(self): return self.Ok() + def __nonzero__(self): return self.IsOk() + def GetLayoutDirection(*args, **kwargs): + """ + GetLayoutDirection(self) -> int + + Get the layout direction (LTR or RTL)_ for this dc. On platforms + where RTL layout is supported, the return value will either be + ``wx.Layout_LeftToRight`` or ``wx.Layout_RightToLeft``. + ``wx.Layout_Default`` is returned if layout direction is not + supported. + """ + return _gdi_.DC_GetLayoutDirection(*args, **kwargs) + + def SetLayoutDirection(*args, **kwargs): + """ + SetLayoutDirection(self, int dir) + + Change the layout direction for this dc. + """ + return _gdi_.DC_SetLayoutDirection(*args, **kwargs) + def GetHDC(*args, **kwargs): """GetHDC(self) -> long""" return _gdi_.DC_GetHDC(*args, **kwargs) @@ -3969,151 +4464,123 @@ class DC(_core.Object): raise ValueError('backgrounds and coords must have same length') return self._DrawTextList(textList, coords, foregrounds, backgrounds) + Background = property(GetBackground,SetBackground,doc="See `GetBackground` and `SetBackground`") + BackgroundMode = property(GetBackgroundMode,SetBackgroundMode,doc="See `GetBackgroundMode` and `SetBackgroundMode`") + BoundingBox = property(GetBoundingBox,doc="See `GetBoundingBox`") + Brush = property(GetBrush,SetBrush,doc="See `GetBrush` and `SetBrush`") + CharHeight = property(GetCharHeight,doc="See `GetCharHeight`") + CharWidth = property(GetCharWidth,doc="See `GetCharWidth`") + ClippingBox = property(GetClippingBox,doc="See `GetClippingBox`") + ClippingRect = property(GetClippingRect,SetClippingRect,doc="See `GetClippingRect` and `SetClippingRect`") + Depth = property(GetDepth,doc="See `GetDepth`") + DeviceOrigin = property(GetDeviceOrigin,SetDeviceOrigin,doc="See `GetDeviceOrigin` and `SetDeviceOrigin`") + Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`") + FullTextExtent = property(GetFullTextExtent,doc="See `GetFullTextExtent`") + LogicalFunction = property(GetLogicalFunction,SetLogicalFunction,doc="See `GetLogicalFunction` and `SetLogicalFunction`") + LogicalOrigin = property(GetLogicalOrigin,SetLogicalOrigin,doc="See `GetLogicalOrigin` and `SetLogicalOrigin`") + LogicalScale = property(GetLogicalScale,SetLogicalScale,doc="See `GetLogicalScale` and `SetLogicalScale`") + MapMode = property(GetMapMode,SetMapMode,doc="See `GetMapMode` and `SetMapMode`") + MultiLineTextExtent = property(GetMultiLineTextExtent,doc="See `GetMultiLineTextExtent`") + Optimization = property(GetOptimization,SetOptimization,doc="See `GetOptimization` and `SetOptimization`") + PPI = property(GetPPI,doc="See `GetPPI`") + PartialTextExtents = property(GetPartialTextExtents,doc="See `GetPartialTextExtents`") + Pen = property(GetPen,SetPen,doc="See `GetPen` and `SetPen`") + Pixel = property(GetPixel,doc="See `GetPixel`") + PixelPoint = property(GetPixelPoint,doc="See `GetPixelPoint`") + Size = property(GetSize,doc="See `GetSize`") + SizeMM = property(GetSizeMM,doc="See `GetSizeMM`") + TextBackground = property(GetTextBackground,SetTextBackground,doc="See `GetTextBackground` and `SetTextBackground`") + TextExtent = property(GetTextExtent,doc="See `GetTextExtent`") + TextForeground = property(GetTextForeground,SetTextForeground,doc="See `GetTextForeground` and `SetTextForeground`") + UserScale = property(GetUserScale,SetUserScale,doc="See `GetUserScale` and `SetUserScale`") + LayoutDirection = property(GetLayoutDirection,SetLayoutDirection) _gdi_.DC_swigregister(DC) #--------------------------------------------------------------------------- -class MemoryDC(DC): +class DCTextColourChanger(object): """ - A memory device context provides a means to draw graphics onto a - bitmap. A bitmap must be selected into the new memory DC before it may - be used for anything. Typical usage is as follows:: - - dc = wx.MemoryDC() - dc.SelectObject(bitmap) - # draw on the dc usign any of the Draw methods - dc.SelectObject(wx.NullBitmap) - # the bitmap now contains wahtever was drawn upon it - - Note that the memory DC *must* be deleted (or the bitmap selected out - of it) before a bitmap can be reselected into another memory DC. - + wx.DCTextColourChanger can be used to temporarily change the DC text + colour and restore it automatically when the object goes out of scope """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ - __init__(self) -> MemoryDC - - Constructs a new memory device context. + __init__(self, DC dc, Colour col) -> DCTextColourChanger - Use the Ok member to test whether the constructor was successful in - creating a usable device context. Don't forget to select a bitmap into - the DC before drawing on it. - """ - _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs)) - def SelectObject(*args, **kwargs): + wx.DCTextColourChanger can be used to temporarily change the DC text + colour and restore it automatically when the object goes out of scope """ - SelectObject(self, Bitmap bitmap) - - Selects the bitmap into the device context, to use as the memory - bitmap. Selecting the bitmap into a memory DC allows you to draw into - the DC, and therefore the bitmap, and also to use Blit to copy the - bitmap to a window. + _gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCTextColourChanger + __del__ = lambda self : None; +_gdi_.DCTextColourChanger_swigregister(DCTextColourChanger) - If the argument is wx.NullBitmap (or some other uninitialised - `wx.Bitmap`) the current bitmap is selected out of the device context, - and the original bitmap restored, allowing the current bitmap to be - destroyed safely. +class DCPenChanger(object): + """ + wx.DCPenChanger can be used to temporarily change the DC pen and + restore it automatically when the object goes out of scope + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): """ - return _gdi_.MemoryDC_SelectObject(*args, **kwargs) + __init__(self, DC dc, Pen pen) -> DCPenChanger -_gdi_.MemoryDC_swigregister(MemoryDC) + wx.DCPenChanger can be used to temporarily change the DC pen and + restore it automatically when the object goes out of scope + """ + _gdi_.DCPenChanger_swiginit(self,_gdi_.new_DCPenChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCPenChanger + __del__ = lambda self : None; +_gdi_.DCPenChanger_swigregister(DCPenChanger) -def MemoryDCFromDC(*args, **kwargs): +class DCBrushChanger(object): """ - MemoryDCFromDC(DC oldDC) -> MemoryDC - - Creates a DC that is compatible with the oldDC. + wx.DCBrushChanger can be used to temporarily change the DC brush and + restore it automatically when the object goes out of scope """ - val = _gdi_.new_MemoryDCFromDC(*args, **kwargs) - return val + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, DC dc, Brush brush) -> DCBrushChanger -#--------------------------------------------------------------------------- + wx.DCBrushChanger can be used to temporarily change the DC brush and + restore it automatically when the object goes out of scope + """ + _gdi_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCBrushChanger + __del__ = lambda self : None; +_gdi_.DCBrushChanger_swigregister(DCBrushChanger) -BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA -BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA -class BufferedDC(MemoryDC): +class DCClipper(object): """ - This simple class provides a simple way to avoid flicker: when drawing - on it, everything is in fact first drawn on an in-memory buffer (a - `wx.Bitmap`) and then copied to the screen only once, when this object - is destroyed. - - It can be used in the same way as any other device - context. wx.BufferedDC itself typically replaces `wx.ClientDC`, if you - want to use it in your EVT_PAINT handler, you should look at - `wx.BufferedPaintDC`. - + wx.wxDCClipper sets the DC's clipping region when it is constructed, + and then automatically destroys the clipping region when the clipper + goes out of scope. """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args): """ - __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC - __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC + __init__(self, DC dc, Region r) -> DCClipper + __init__(self, DC dc, Rect r) -> DCClipper + __init__(self, DC dc, int x, int y, int w, int h) -> DCClipper - Constructs a buffered DC. + wx.wxDCClipper sets the DC's clipping region when it is constructed, + and then automatically destroys the clipping region when the clipper + goes out of scope. """ - _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args)) - self.__dc = args[0] # save a ref so the other dc will not be deleted before self - - __swig_destroy__ = _gdi_.delete_BufferedDC + _gdi_.DCClipper_swiginit(self,_gdi_.new_DCClipper(*args)) + __swig_destroy__ = _gdi_.delete_DCClipper __del__ = lambda self : None; - def UnMask(*args, **kwargs): - """ - UnMask(self) - - Blits the buffer to the dc, and detaches the dc from the buffer (so it - can be effectively used once only). This is usually only called in - the destructor. - """ - return _gdi_.BufferedDC_UnMask(*args, **kwargs) +_gdi_.DCClipper_swigregister(DCClipper) -_gdi_.BufferedDC_swigregister(BufferedDC) +#--------------------------------------------------------------------------- -class BufferedPaintDC(BufferedDC): - """ - This is a subclass of `wx.BufferedDC` which can be used inside of an - EVT_PAINT event handler. Just create an object of this class instead - of `wx.PaintDC` and that's all you have to do to (mostly) avoid - flicker. The only thing to watch out for is that if you are using this - class together with `wx.ScrolledWindow`, you probably do **not** want - to call `wx.Window.PrepareDC` on it as it already does this internally - for the real underlying `wx.PaintDC`. - - If your window is already fully buffered in a `wx.Bitmap` then your - EVT_PAINT handler can be as simple as just creating a - ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window - automatically when it is destroyed. For example:: - - def OnPaint(self, event): - dc = wx.BufferedPaintDC(self, self.buffer) - - - - - - """ - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args, **kwargs): - """ - __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC - - Create a buffered paint DC. As with `wx.BufferedDC`, you may either - provide the bitmap to be used for buffering or let this object create - one internally (in the latter case, the size of the client part of the - window is automatically used). - - - """ - _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs)) -_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC) - -#--------------------------------------------------------------------------- - -class ScreenDC(DC): +class ScreenDC(DC): """ A wxScreenDC can be used to paint anywhere on the screen. This should normally be constructed as a temporary stack object; don't store a @@ -4171,233 +4638,1415 @@ class ScreenDC(DC): function allows the screen to be refreshed afterwards may be useful to some applications. """ - return _gdi_.ScreenDC_EndDrawingOnTop(*args, **kwargs) + return _gdi_.ScreenDC_EndDrawingOnTop(*args, **kwargs) + +_gdi_.ScreenDC_swigregister(ScreenDC) + +#--------------------------------------------------------------------------- + +class WindowDC(DC): + """ + A wx.WindowDC must be constructed if an application wishes to paint on + the whole area of a window (client and decorations). This should + normally be constructed as a temporary stack object; don't store a + wx.WindowDC object. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, Window win) -> WindowDC + + Constructor. Pass the window on which you wish to paint. + """ + _gdi_.WindowDC_swiginit(self,_gdi_.new_WindowDC(*args, **kwargs)) +_gdi_.WindowDC_swigregister(WindowDC) + +#--------------------------------------------------------------------------- + +class ClientDC(WindowDC): + """ + A wx.ClientDC must be constructed if an application wishes to paint on + the client area of a window from outside an EVT_PAINT event. This should + normally be constructed as a temporary stack object; don't store a + wx.ClientDC object long term. + + To draw on a window from within an EVT_PAINT handler, construct a + `wx.PaintDC` object. + + To draw on the whole window including decorations, construct a + `wx.WindowDC` object (Windows only). + + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, Window win) -> ClientDC + + Constructor. Pass the window on which you wish to paint. + """ + _gdi_.ClientDC_swiginit(self,_gdi_.new_ClientDC(*args, **kwargs)) +_gdi_.ClientDC_swigregister(ClientDC) + +#--------------------------------------------------------------------------- + +class PaintDC(ClientDC): + """ + A wx.PaintDC must be constructed if an application wishes to paint on + the client area of a window from within an EVT_PAINT event + handler. This should normally be constructed as a temporary stack + object; don't store a wx.PaintDC object. If you have an EVT_PAINT + handler, you **must** create a wx.PaintDC object within it even if you + don't actually use it. + + Using wx.PaintDC within EVT_PAINT handlers is important because it + automatically sets the clipping area to the damaged area of the + window. Attempts to draw outside this area do not appear. + + To draw on a window from outside EVT_PAINT handlers, construct a + `wx.ClientDC` object. + + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, Window win) -> PaintDC + + Constructor. Pass the window on which you wish to paint. + """ + _gdi_.PaintDC_swiginit(self,_gdi_.new_PaintDC(*args, **kwargs)) +_gdi_.PaintDC_swigregister(PaintDC) + +#--------------------------------------------------------------------------- + +class MemoryDC(WindowDC): + """ + A memory device context provides a means to draw graphics onto a + bitmap. A bitmap must be selected into the new memory DC before it may + be used for anything. Typical usage is as follows:: + + dc = wx.MemoryDC() + dc.SelectObject(bitmap) + # draw on the dc using any of the Draw methods + dc.SelectObject(wx.NullBitmap) + # the bitmap now contains wahtever was drawn upon it + + Note that the memory DC *must* be deleted (or the bitmap selected out + of it) before a bitmap can be reselected into another memory DC. + + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, Bitmap bitmap=NullBitmap) -> MemoryDC + + Constructs a new memory device context. + + Use the Ok member to test whether the constructor was successful in + creating a usable device context. If a bitmap is not given to this + constructor then don't forget to select a bitmap into the DC before + drawing on it. + """ + _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs)) + def SelectObject(*args, **kwargs): + """ + SelectObject(self, Bitmap bitmap) + + Selects the bitmap into the device context, to use as the memory + bitmap. Selecting the bitmap into a memory DC allows you to draw into + the DC, and therefore the bitmap, and also to use Blit to copy the + bitmap to a window. + + If the argument is wx.NullBitmap (or some other uninitialised + `wx.Bitmap`) the current bitmap is selected out of the device context, + and the original bitmap restored, allowing the current bitmap to be + destroyed safely. + """ + return _gdi_.MemoryDC_SelectObject(*args, **kwargs) + + def SelectObjectAsSource(*args, **kwargs): + """SelectObjectAsSource(self, Bitmap bmp)""" + return _gdi_.MemoryDC_SelectObjectAsSource(*args, **kwargs) + +_gdi_.MemoryDC_swigregister(MemoryDC) + +def MemoryDCFromDC(*args, **kwargs): + """ + MemoryDCFromDC(DC oldDC) -> MemoryDC + + Creates a DC that is compatible with the oldDC. + """ + val = _gdi_.new_MemoryDCFromDC(*args, **kwargs) + return val + +#--------------------------------------------------------------------------- + +BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA +BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA +class BufferedDC(MemoryDC): + """ + This simple class provides a simple way to avoid flicker: when drawing + on it, everything is in fact first drawn on an in-memory buffer (a + `wx.Bitmap`) and then copied to the screen only once, when this object + is destroyed. You can either provide a buffer bitmap yourself, and + reuse it the next time something needs painted, or you can let the + buffered DC create and provide a buffer bitmap itself. + + Buffered DCs can be used in the same way as any other device context. + wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to + use it in your EVT_PAINT handler, you should look at + `wx.BufferedPaintDC`. You can also use a wx.BufferedDC without + providing a target DC. In this case the operations done on the dc + will only be written to the buffer bitmap and *not* to any window, so + you will want to have provided the buffer bitmap and then reuse it + when it needs painted to the window. + + Please note that GTK+ 2.0 and OS X provide double buffering themselves + natively. You may want to use `wx.Window.IsDoubleBuffered` to + determine whether you need to use buffering or not, or use + `wx.AutoBufferedPaintDC` to avoid needless double buffering on systems + that already do it automatically. + + + + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC + __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC + + Constructs a buffered DC. + """ + _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args)) + self.__dc = args[0] # save a ref so the other dc will not be deleted before self + + __swig_destroy__ = _gdi_.delete_BufferedDC + __del__ = lambda self : None; + def UnMask(*args, **kwargs): + """ + UnMask(self) + + Blits the buffer to the dc, and detaches the dc from the buffer (so it + can be effectively used once only). This is usually only called in + the destructor. + """ + return _gdi_.BufferedDC_UnMask(*args, **kwargs) + + def SetStyle(*args, **kwargs): + """SetStyle(self, int style)""" + return _gdi_.BufferedDC_SetStyle(*args, **kwargs) + + def GetStyle(*args, **kwargs): + """GetStyle(self) -> int""" + return _gdi_.BufferedDC_GetStyle(*args, **kwargs) + +_gdi_.BufferedDC_swigregister(BufferedDC) + +class BufferedPaintDC(BufferedDC): + """ + This is a subclass of `wx.BufferedDC` which can be used inside of an + EVT_PAINT event handler. Just create an object of this class instead + of `wx.PaintDC` and that's all you have to do to (mostly) avoid + flicker. The only thing to watch out for is that if you are using this + class together with `wx.ScrolledWindow`, you probably do **not** want + to call `wx.Window.PrepareDC` on it as it already does this internally + for the real underlying `wx.PaintDC`. + + If your window is already fully buffered in a `wx.Bitmap` then your + EVT_PAINT handler can be as simple as just creating a + ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window + automatically when it is destroyed. For example:: + + def OnPaint(self, event): + dc = wx.BufferedPaintDC(self, self.buffer) + + + + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC + + Create a buffered paint DC. As with `wx.BufferedDC`, you may either + provide the bitmap to be used for buffering or let this object create + one internally (in the latter case, the size of the client part of the + window is automatically used). + """ + _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs)) +_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC) + +#--------------------------------------------------------------------------- + +class AutoBufferedPaintDC(DC): + """ + If the current platform double buffers by default then this DC is the + same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`. + + :see: `wx.AutoBufferedPaintDCFactory` + + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, Window win) -> AutoBufferedPaintDC + + If the current platform double buffers by default then this DC is the + same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`. + + :see: `wx.AutoBufferedPaintDCFactory` + + """ + _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs)) +_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC) + + +def AutoBufferedPaintDCFactory(*args, **kwargs): + """ + AutoBufferedPaintDCFactory(Window window) -> DC + + Checks if the window is natively double buffered and will return a + `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise. The advantage of + this function over `wx.AutoBufferedPaintDC` is that this function will check + if the the specified window has double-buffering enabled rather than just + going by platform defaults. + """ + return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs) +#--------------------------------------------------------------------------- + +class MirrorDC(DC): + """ + wx.MirrorDC is a simple wrapper class which is always associated with a + real `wx.DC` object and either forwards all of its operations to it + without changes (no mirroring takes place) or exchanges x and y + coordinates which makes it possible to reuse the same code to draw a + figure and its mirror -- i.e. reflection related to the diagonal line + x == y. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, DC dc, bool mirror) -> MirrorDC + + Creates a mirrored DC associated with the real *dc*. Everything drawn + on the wx.MirrorDC will appear on the *dc*, and will be mirrored if + *mirror* is True. + """ + _gdi_.MirrorDC_swiginit(self,_gdi_.new_MirrorDC(*args, **kwargs)) +_gdi_.MirrorDC_swigregister(MirrorDC) + +#--------------------------------------------------------------------------- + +class PostScriptDC(DC): + """This is a `wx.DC` that can write to PostScript files on any platform.""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, wxPrintData printData) -> PostScriptDC + + Constructs a PostScript printer device context from a `wx.PrintData` + object. + """ + _gdi_.PostScriptDC_swiginit(self,_gdi_.new_PostScriptDC(*args, **kwargs)) + def GetPrintData(*args, **kwargs): + """GetPrintData(self) -> wxPrintData""" + return _gdi_.PostScriptDC_GetPrintData(*args, **kwargs) + + def SetPrintData(*args, **kwargs): + """SetPrintData(self, wxPrintData data)""" + return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs) + + def SetResolution(*args, **kwargs): + """ + SetResolution(int ppi) + + Set resolution (in pixels per inch) that will be used in PostScript + output. Default is 720ppi. + """ + return _gdi_.PostScriptDC_SetResolution(*args, **kwargs) + + SetResolution = staticmethod(SetResolution) + def GetResolution(*args, **kwargs): + """ + GetResolution() -> int + + Return resolution used in PostScript output. + """ + return _gdi_.PostScriptDC_GetResolution(*args, **kwargs) + + GetResolution = staticmethod(GetResolution) + PrintData = property(GetPrintData,SetPrintData,doc="See `GetPrintData` and `SetPrintData`") +_gdi_.PostScriptDC_swigregister(PostScriptDC) + +def PostScriptDC_SetResolution(*args, **kwargs): + """ + PostScriptDC_SetResolution(int ppi) + + Set resolution (in pixels per inch) that will be used in PostScript + output. Default is 720ppi. + """ + return _gdi_.PostScriptDC_SetResolution(*args, **kwargs) + +def PostScriptDC_GetResolution(*args): + """ + PostScriptDC_GetResolution() -> int + + Return resolution used in PostScript output. + """ + return _gdi_.PostScriptDC_GetResolution(*args) + +#--------------------------------------------------------------------------- + +class MetaFile(_core.Object): + """Proxy of C++ MetaFile class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self, String filename=EmptyString) -> MetaFile""" + _gdi_.MetaFile_swiginit(self,_gdi_.new_MetaFile(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_MetaFile + __del__ = lambda self : None; + def IsOk(*args, **kwargs): + """IsOk(self) -> bool""" + return _gdi_.MetaFile_IsOk(*args, **kwargs) + + Ok = IsOk + def SetClipboard(*args, **kwargs): + """SetClipboard(self, int width=0, int height=0) -> bool""" + return _gdi_.MetaFile_SetClipboard(*args, **kwargs) + + def GetSize(*args, **kwargs): + """GetSize(self) -> Size""" + return _gdi_.MetaFile_GetSize(*args, **kwargs) + + def GetWidth(*args, **kwargs): + """GetWidth(self) -> int""" + return _gdi_.MetaFile_GetWidth(*args, **kwargs) + + def GetHeight(*args, **kwargs): + """GetHeight(self) -> int""" + return _gdi_.MetaFile_GetHeight(*args, **kwargs) + + def GetFileName(*args, **kwargs): + """GetFileName(self) -> String""" + return _gdi_.MetaFile_GetFileName(*args, **kwargs) + + def __nonzero__(self): return self.IsOk() +_gdi_.MetaFile_swigregister(MetaFile) + +class MetaFileDC(DC): + """Proxy of C++ MetaFileDC class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, String filename=EmptyString, int width=0, int height=0, + String description=EmptyString) -> MetaFileDC + """ + _gdi_.MetaFileDC_swiginit(self,_gdi_.new_MetaFileDC(*args, **kwargs)) + def Close(*args, **kwargs): + """Close(self) -> MetaFile""" + return _gdi_.MetaFileDC_Close(*args, **kwargs) + +_gdi_.MetaFileDC_swigregister(MetaFileDC) + +class PrinterDC(DC): + """Proxy of C++ PrinterDC class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self, wxPrintData printData) -> PrinterDC""" + _gdi_.PrinterDC_swiginit(self,_gdi_.new_PrinterDC(*args, **kwargs)) +_gdi_.PrinterDC_swigregister(PrinterDC) + +#--------------------------------------------------------------------------- + +class GraphicsObject(_core.Object): + """ + This class is the superclass of native graphics objects like pens + etc. It provides the internal reference counting. It is not to be + instantiated by user code. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, GraphicsRenderer renderer=None) -> GraphicsObject + + This class is the superclass of native graphics objects like pens + etc. It provides the internal reference counting. It is not to be + instantiated by user code. + """ + _gdi_.GraphicsObject_swiginit(self,_gdi_.new_GraphicsObject(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsObject + __del__ = lambda self : None; + def IsNull(*args, **kwargs): + """ + IsNull(self) -> bool + + Is this object valid (false) or still empty (true)? + """ + return _gdi_.GraphicsObject_IsNull(*args, **kwargs) + + def GetRenderer(*args, **kwargs): + """ + GetRenderer(self) -> GraphicsRenderer + + Returns the renderer that was used to create this instance, or + ``None`` if it has not been initialized yet. + """ + return _gdi_.GraphicsObject_GetRenderer(*args, **kwargs) + +_gdi_.GraphicsObject_swigregister(GraphicsObject) + +class GraphicsPen(GraphicsObject): + """ + A wx.GraphicsPen is a native representation of a pen. It is used for + stroking a path on a `wx.GraphicsContext`. The contents are specific and + private to the respective renderer. The only way to get a valid instance + is via a CreatePen call on the graphics context or the renderer + instance. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self) -> GraphicsPen + + A wx.GraphicsPen is a native representation of a pen. It is used for + stroking a path on a `wx.GraphicsContext`. The contents are specific and + private to the respective renderer. The only way to get a valid instance + is via a CreatePen call on the graphics context or the renderer + instance. + """ + _gdi_.GraphicsPen_swiginit(self,_gdi_.new_GraphicsPen(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsPen + __del__ = lambda self : None; +_gdi_.GraphicsPen_swigregister(GraphicsPen) + +class GraphicsBrush(GraphicsObject): + """ + A wx.GraphicsBrush is a native representation of a brush. It is used + for filling a path on a `wx.GraphicsContext`. The contents are + specific and private to the respective renderer. The only way to get a + valid instance is via a Create...Brush call on the graphics context or + the renderer instance. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self) -> GraphicsBrush + + A wx.GraphicsBrush is a native representation of a brush. It is used + for filling a path on a `wx.GraphicsContext`. The contents are + specific and private to the respective renderer. The only way to get a + valid instance is via a Create...Brush call on the graphics context or + the renderer instance. + """ + _gdi_.GraphicsBrush_swiginit(self,_gdi_.new_GraphicsBrush(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsBrush + __del__ = lambda self : None; +_gdi_.GraphicsBrush_swigregister(GraphicsBrush) + +class GraphicsFont(GraphicsObject): + """ + A `wx.GraphicsFont` is a native representation of a font (including + text colour). The contents are specific an private to the respective + renderer. The only way to get a valid instance is via a CreateFont + call on the graphics context or the renderer instance. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self) -> GraphicsFont + + A `wx.GraphicsFont` is a native representation of a font (including + text colour). The contents are specific an private to the respective + renderer. The only way to get a valid instance is via a CreateFont + call on the graphics context or the renderer instance. + """ + _gdi_.GraphicsFont_swiginit(self,_gdi_.new_GraphicsFont(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsFont + __del__ = lambda self : None; +_gdi_.GraphicsFont_swigregister(GraphicsFont) + +class GraphicsMatrix(GraphicsObject): + """ + A wx.GraphicsMatrix is a native representation of an affine + matrix. The contents are specific an private to the respective + renderer. The only way to get a valid instance is via a CreateMatrix + call on the graphics context or the renderer instance. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self) -> GraphicsMatrix + + A wx.GraphicsMatrix is a native representation of an affine + matrix. The contents are specific an private to the respective + renderer. The only way to get a valid instance is via a CreateMatrix + call on the graphics context or the renderer instance. + """ + _gdi_.GraphicsMatrix_swiginit(self,_gdi_.new_GraphicsMatrix(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsMatrix + __del__ = lambda self : None; + def Concat(*args, **kwargs): + """ + Concat(self, GraphicsMatrix t) + + Concatenates the passed in matrix to the current matrix. + """ + return _gdi_.GraphicsMatrix_Concat(*args, **kwargs) + + def Set(*args, **kwargs): + """ + Set(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, + Double tx=0.0, Double ty=0.0) + + Sets the matrix to the specified values (default values are the + identity matrix.) + """ + return _gdi_.GraphicsMatrix_Set(*args, **kwargs) + + def Invert(*args, **kwargs): + """ + Invert(self) + + Inverts the matrix. + """ + return _gdi_.GraphicsMatrix_Invert(*args, **kwargs) + + def IsEqual(*args, **kwargs): + """ + IsEqual(self, GraphicsMatrix t) -> bool + + Returns ``True`` if the elements of the transformation matrix are equal + """ + return _gdi_.GraphicsMatrix_IsEqual(*args, **kwargs) + + def IsIdentity(*args, **kwargs): + """ + IsIdentity(self) -> bool + + Returns ``True`` if this is the identity matrix + """ + return _gdi_.GraphicsMatrix_IsIdentity(*args, **kwargs) + + def Translate(*args, **kwargs): + """ + Translate(self, Double dx, Double dy) + + Add a translation to this matrix. + """ + return _gdi_.GraphicsMatrix_Translate(*args, **kwargs) + + def Scale(*args, **kwargs): + """ + Scale(self, Double xScale, Double yScale) + + Scales this matrix. + """ + return _gdi_.GraphicsMatrix_Scale(*args, **kwargs) + + def Rotate(*args, **kwargs): + """ + Rotate(self, Double angle) + + Rotates this matrix. The angle should be specified in radians. + """ + return _gdi_.GraphicsMatrix_Rotate(*args, **kwargs) + + def TransformPoint(*args, **kwargs): + """ + TransformPoint(self, x, y) --> (x, y) + + Applies this matrix to a point, returns the resulting point values + """ + return _gdi_.GraphicsMatrix_TransformPoint(*args, **kwargs) + + def TransformDistance(*args, **kwargs): + """ + TransformDistance(self, dx, dy) --> (dx, dy) + + Applies this matrix to a distance (ie. performs all transforms except + translations) + """ + return _gdi_.GraphicsMatrix_TransformDistance(*args, **kwargs) + + def GetNativeMatrix(*args, **kwargs): + """ + GetNativeMatrix(self) -> void + + Returns the native representation of the matrix. For CoreGraphics this + is a CFAffineMatrix pointer. For GDIPlus a Matrix Pointer and for + Cairo a cairo_matrix_t pointer. NOTE: For wxPython we still need a + way to make this value usable. + """ + return _gdi_.GraphicsMatrix_GetNativeMatrix(*args, **kwargs) + +_gdi_.GraphicsMatrix_swigregister(GraphicsMatrix) + +class GraphicsPath(GraphicsObject): + """Proxy of C++ GraphicsPath class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """__init__(self) -> GraphicsPath""" + _gdi_.GraphicsPath_swiginit(self,_gdi_.new_GraphicsPath(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_GraphicsPath + __del__ = lambda self : None; + def MoveToPoint(*args): + """ + MoveToPoint(self, Double x, Double y) + MoveToPoint(self, Point2D p) + + Begins a new subpath at the specified point. + """ + return _gdi_.GraphicsPath_MoveToPoint(*args) + + def AddLineToPoint(*args): + """ + AddLineToPoint(self, Double x, Double y) + AddLineToPoint(self, Point2D p) + + Adds a straight line from the current point to the specified point. + """ + return _gdi_.GraphicsPath_AddLineToPoint(*args) + + def AddCurveToPoint(*args): + """ + AddCurveToPoint(self, Double cx1, Double cy1, Double cx2, Double cy2, Double x, + Double y) + AddCurveToPoint(self, Point2D c1, Point2D c2, Point2D e) + + Adds a cubic Bezier curve from the current point, using two control + points and an end point + """ + return _gdi_.GraphicsPath_AddCurveToPoint(*args) + + def AddPath(*args, **kwargs): + """ + AddPath(self, GraphicsPath path) + + Adds another path + """ + return _gdi_.GraphicsPath_AddPath(*args, **kwargs) + + def CloseSubpath(*args, **kwargs): + """ + CloseSubpath(self) + + Closes the current sub-path. + """ + return _gdi_.GraphicsPath_CloseSubpath(*args, **kwargs) + + def GetCurrentPoint(*args, **kwargs): + """ + GetCurrentPoint(self) -> Point2D + + Gets the last point of the current path, (0,0) if not yet set + """ + return _gdi_.GraphicsPath_GetCurrentPoint(*args, **kwargs) + + def AddArc(*args): + """ + AddArc(self, Double x, Double y, Double r, Double startAngle, Double endAngle, + bool clockwise) + AddArc(self, Point2D c, Double r, Double startAngle, Double endAngle, + bool clockwise) + + Adds an arc of a circle centering at (x,y) with radius (r) from + startAngle to endAngle + """ + return _gdi_.GraphicsPath_AddArc(*args) + + def AddQuadCurveToPoint(*args, **kwargs): + """ + AddQuadCurveToPoint(self, Double cx, Double cy, Double x, Double y) + + Adds a quadratic Bezier curve from the current point, using a control + point and an end point + """ + return _gdi_.GraphicsPath_AddQuadCurveToPoint(*args, **kwargs) + + def AddRectangle(*args, **kwargs): + """ + AddRectangle(self, Double x, Double y, Double w, Double h) + + Appends a rectangle as a new closed subpath. + """ + return _gdi_.GraphicsPath_AddRectangle(*args, **kwargs) + + def AddCircle(*args, **kwargs): + """ + AddCircle(self, Double x, Double y, Double r) + + Appends a circle around (x,y) with radius r as a new closed subpath. + """ + return _gdi_.GraphicsPath_AddCircle(*args, **kwargs) + + def AddArcToPoint(*args, **kwargs): + """ + AddArcToPoint(self, Double x1, Double y1, Double x2, Double y2, Double r) + + Appends an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) + to (x2,y2), also a straight line from (current) to (x1,y1) + """ + return _gdi_.GraphicsPath_AddArcToPoint(*args, **kwargs) + + def AddEllipse(*args, **kwargs): + """ + AddEllipse(self, Double x, Double y, Double w, Double h) + + Appends an ellipse fitting into the passed in rectangle. + """ + return _gdi_.GraphicsPath_AddEllipse(*args, **kwargs) + + def AddRoundedRectangle(*args, **kwargs): + """ + AddRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius) + + Appends a rounded rectangle. + """ + return _gdi_.GraphicsPath_AddRoundedRectangle(*args, **kwargs) + + def GetNativePath(*args, **kwargs): + """ + GetNativePath(self) -> void + + Returns the native path (CGPathRef for Core Graphics, Path pointer for + GDIPlus and a cairo_path_t pointer for cairo). NOTE: For wxPython we + still need a way to make this value usable. + """ + return _gdi_.GraphicsPath_GetNativePath(*args, **kwargs) + + def UnGetNativePath(*args, **kwargs): + """ + UnGetNativePath(self, void p) + + Gives back the native path returned by GetNativePath() because there + might be some deallocations necessary (eg on cairo the native path + returned by GetNativePath is newly allocated each time). + """ + return _gdi_.GraphicsPath_UnGetNativePath(*args, **kwargs) + + def Transform(*args, **kwargs): + """ + Transform(self, GraphicsMatrix matrix) + + Transforms each point of this path by the matrix + """ + return _gdi_.GraphicsPath_Transform(*args, **kwargs) + + def GetBox(*args, **kwargs): + """ + GetBox(self) -> wxRect2DDouble + + Gets the bounding box enclosing all points (possibly including control points) + """ + return _gdi_.GraphicsPath_GetBox(*args, **kwargs) + + def Contains(*args): + """ + Contains(self, Double x, Double y, int fillStyle=ODDEVEN_RULE) -> bool + Contains(self, wxPoint2DDouble c, int fillStyle=ODDEVEN_RULE) -> bool + + Returns ``True`` if the point is within the path. + """ + return _gdi_.GraphicsPath_Contains(*args) + +_gdi_.GraphicsPath_swigregister(GraphicsPath) + +class GraphicsContext(GraphicsObject): + """ + A `wx.GraphicsContext` instance is the object that is drawn upon. It is + created by a renderer using the CreateContext calls, this can be done + either directly using a renderer instance, or indirectly using the + static convenience CreateXXX functions of wx.GraphicsContext that + always delegate the task to the default renderer. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self): raise AttributeError, "No constructor defined" + __repr__ = _swig_repr + __swig_destroy__ = _gdi_.delete_GraphicsContext + __del__ = lambda self : None; + def Create(*args): + """ + Create(WindowDC dc) -> GraphicsContext + Create(Window window) -> GraphicsContext + + Creates a wx.GraphicsContext either from a window or a DC. + """ + val = _gdi_.GraphicsContext_Create(*args) + val.__dc = args[0] # save a ref so the dc will not be deleted before self + return val + + Create = staticmethod(Create) + def CreateMeasuringContext(*args): + """ + CreateMeasuringContext() -> GraphicsContext + + Create a lightwieght context that can be used for measuring text only. + """ + val = _gdi_.GraphicsContext_CreateMeasuringContext(*args) + val.__dc = args[0] # save a ref so the dc will not be deleted before self + return val + + CreateMeasuringContext = staticmethod(CreateMeasuringContext) + def CreateFromNative(*args, **kwargs): + """ + CreateFromNative(void context) -> GraphicsContext + + Creates a wx.GraphicsContext from a native context. This native context + must be eg a CGContextRef for Core Graphics, a Graphics pointer for + GDIPlus or a cairo_t pointer for Cairo. + """ + return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs) + + CreateFromNative = staticmethod(CreateFromNative) + def CreateFromNativeWindow(*args, **kwargs): + """ + CreateFromNativeWindow(void window) -> GraphicsContext + + Creates a wx.GraphicsContext from a native window. + """ + return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs) + + CreateFromNativeWindow = staticmethod(CreateFromNativeWindow) + def CreatePath(*args, **kwargs): + """ + CreatePath(self) -> GraphicsPath + + Creates a native graphics path which is initially empty. + """ + return _gdi_.GraphicsContext_CreatePath(*args, **kwargs) + + def CreatePen(*args, **kwargs): + """ + CreatePen(self, Pen pen) -> GraphicsPen + + Creates a native pen from a `wx.Pen`. + """ + return _gdi_.GraphicsContext_CreatePen(*args, **kwargs) + + def CreateBrush(*args, **kwargs): + """ + CreateBrush(self, Brush brush) -> GraphicsBrush + + Creates a native brush from a `wx.Brush`. + """ + return _gdi_.GraphicsContext_CreateBrush(*args, **kwargs) + + def CreateLinearGradientBrush(*args, **kwargs): + """ + CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1, + Colour c2) -> GraphicsBrush + + Creates a native brush, having a linear gradient, starting at (x1,y1) + with color c1 to (x2,y2) with color c2. + """ + return _gdi_.GraphicsContext_CreateLinearGradientBrush(*args, **kwargs) + + def CreateRadialGradientBrush(*args, **kwargs): + """ + CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius, + Colour oColor, Colour cColor) -> GraphicsBrush + + Creates a native brush, having a radial gradient originating at + point (xo,yc) with color oColour and ends on a circle around (xc,yc) with + radius r and color cColour. + """ + return _gdi_.GraphicsContext_CreateRadialGradientBrush(*args, **kwargs) + + def CreateFont(*args, **kwargs): + """ + CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont + + Creates a native graphics font from a `wx.Font` and a text colour. + """ + return _gdi_.GraphicsContext_CreateFont(*args, **kwargs) + + def CreateMatrix(*args, **kwargs): + """ + CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, + Double tx=0.0, Double ty=0.0) -> GraphicsMatrix + + Creates a native affine transformation matrix from the passed in + values. The defaults result in an identity matrix. + """ + return _gdi_.GraphicsContext_CreateMatrix(*args, **kwargs) + + def PushState(*args, **kwargs): + """ + PushState(self) + + push the current state of the context, ie the transformation matrix on a stack + """ + return _gdi_.GraphicsContext_PushState(*args, **kwargs) + + def PopState(*args, **kwargs): + """ + PopState(self) + + pops a stored state from the stack + """ + return _gdi_.GraphicsContext_PopState(*args, **kwargs) + + def ClipRegion(*args, **kwargs): + """ + ClipRegion(self, Region region) + + Clips drawings to the region, combined to current clipping region. + """ + return _gdi_.GraphicsContext_ClipRegion(*args, **kwargs) + + def Clip(*args, **kwargs): + """ + Clip(self, Double x, Double y, Double w, Double h) + + Clips drawings to the rectangle. + """ + return _gdi_.GraphicsContext_Clip(*args, **kwargs) + + def ResetClip(*args, **kwargs): + """ + ResetClip(self) + + Resets the clipping to original shape. + """ + return _gdi_.GraphicsContext_ResetClip(*args, **kwargs) + + def GetNativeContext(*args, **kwargs): + """ + GetNativeContext(self) -> void + + Returns the native context (CGContextRef for Core Graphics, Graphics + pointer for GDIPlus and cairo_t pointer for cairo). + """ + return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs) + + def Translate(*args, **kwargs): + """ + Translate(self, Double dx, Double dy) + + Translates the current transformation matrix. + """ + return _gdi_.GraphicsContext_Translate(*args, **kwargs) + + def Scale(*args, **kwargs): + """ + Scale(self, Double xScale, Double yScale) + + Scale the current transformation matrix of the context. + """ + return _gdi_.GraphicsContext_Scale(*args, **kwargs) + + def Rotate(*args, **kwargs): + """ + Rotate(self, Double angle) + + Rotate the current transformation matrix of the context. ``angle`` is + specified in radians. + """ + return _gdi_.GraphicsContext_Rotate(*args, **kwargs) + + def ConcatTransform(*args, **kwargs): + """ + ConcatTransform(self, GraphicsMatrix matrix) + + Concatenates the passed in transform with the current transform of + this context. + """ + return _gdi_.GraphicsContext_ConcatTransform(*args, **kwargs) + + def SetTransform(*args, **kwargs): + """ + SetTransform(self, GraphicsMatrix matrix) + + Sets the current transform of this context. + """ + return _gdi_.GraphicsContext_SetTransform(*args, **kwargs) + + def GetTransform(*args, **kwargs): + """ + GetTransform(self) -> GraphicsMatrix + + Gets the current transformation matrix of this context. + """ + return _gdi_.GraphicsContext_GetTransform(*args, **kwargs) + + def SetPen(*args): + """ + SetPen(self, GraphicsPen pen) + SetPen(self, Pen pen) + + Sets the stroke pen + """ + return _gdi_.GraphicsContext_SetPen(*args) + + def SetBrush(*args): + """ + SetBrush(self, GraphicsBrush brush) + SetBrush(self, Brush brush) + + Sets the brush for filling + """ + return _gdi_.GraphicsContext_SetBrush(*args) + + def SetFont(*args): + """ + SetFont(self, GraphicsFont font) + SetFont(self, Font font, Colour colour=*wxBLACK) + + Sets the font + """ + return _gdi_.GraphicsContext_SetFont(*args) + + def StrokePath(*args, **kwargs): + """ + StrokePath(self, GraphicsPath path) + + Strokes along a path with the current pen. + """ + return _gdi_.GraphicsContext_StrokePath(*args, **kwargs) + + def FillPath(*args, **kwargs): + """ + FillPath(self, GraphicsPath path, int fillStyle=ODDEVEN_RULE) + + Fills a path with the current brush. + """ + return _gdi_.GraphicsContext_FillPath(*args, **kwargs) + + def DrawPath(*args, **kwargs): + """ + DrawPath(self, GraphicsPath path, int fillStyle=ODDEVEN_RULE) + + Draws the path by first filling and then stroking. + """ + return _gdi_.GraphicsContext_DrawPath(*args, **kwargs) + + def DrawText(*args, **kwargs): + """ + DrawText(self, String str, Double x, Double y, GraphicsBrush backgroundBrush=NullGraphicsBrush) + + Draws a text string at the defined position. + """ + return _gdi_.GraphicsContext_DrawText(*args, **kwargs) + + def DrawRotatedText(*args, **kwargs): + """ + DrawRotatedText(self, String str, Double x, Double y, Double angle, GraphicsBrush backgroundBrush=NullGraphicsBrush) -_gdi_.ScreenDC_swigregister(ScreenDC) + Draws a text string at the defined position, at the specified angle, + which is given in radians. + """ + return _gdi_.GraphicsContext_DrawRotatedText(*args, **kwargs) -#--------------------------------------------------------------------------- + def GetFullTextExtent(*args, **kwargs): + """ + GetFullTextExtent(self, text) --> (width, height, descent, externalLeading) -class ClientDC(DC): - """ - A wx.ClientDC must be constructed if an application wishes to paint on - the client area of a window from outside an EVT_PAINT event. This should - normally be constructed as a temporary stack object; don't store a - wx.ClientDC object long term. + Gets the dimensions of the string using the currently selected + font. ``text`` is the string to measure, ``w`` and ``h`` are the total + width and height respectively, ``descent`` is the dimension from the + baseline of the font to the bottom of the descender, and + ``externalLeading`` is any extra vertical space added to the font by + the font designer (usually is zero). + """ + return _gdi_.GraphicsContext_GetFullTextExtent(*args, **kwargs) - To draw on a window from within an EVT_PAINT handler, construct a - `wx.PaintDC` object. + def GetTextExtent(*args, **kwargs): + """ + GetTextExtent(self, text) --> (width, height) - To draw on the whole window including decorations, construct a - `wx.WindowDC` object (Windows only). + Gets the dimensions of the string using the currently selected + font. ``text`` is the string to measure, ``w`` and ``h`` are the total + width and height respectively. + """ + return _gdi_.GraphicsContext_GetTextExtent(*args, **kwargs) - """ - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args, **kwargs): + def GetPartialTextExtents(*args, **kwargs): """ - __init__(self, Window win) -> ClientDC + GetPartialTextExtents(self, text) -> [widths] - Constructor. Pass the window on which you wish to paint. + Returns a list of widths from the beginning of ``text`` to the + coresponding character in ``text``. """ - _gdi_.ClientDC_swiginit(self,_gdi_.new_ClientDC(*args, **kwargs)) -_gdi_.ClientDC_swigregister(ClientDC) + return _gdi_.GraphicsContext_GetPartialTextExtents(*args, **kwargs) -#--------------------------------------------------------------------------- + def DrawBitmap(*args, **kwargs): + """ + DrawBitmap(self, Bitmap bmp, Double x, Double y, Double w, Double h) -class PaintDC(DC): - """ - A wx.PaintDC must be constructed if an application wishes to paint on - the client area of a window from within an EVT_PAINT event - handler. This should normally be constructed as a temporary stack - object; don't store a wx.PaintDC object. If you have an EVT_PAINT - handler, you **must** create a wx.PaintDC object within it even if you - don't actually use it. + Draws the bitmap. In case of a mono bitmap, this is treated as a mask + and the current brush is used for filling. + """ + return _gdi_.GraphicsContext_DrawBitmap(*args, **kwargs) - Using wx.PaintDC within EVT_PAINT handlers is important because it - automatically sets the clipping area to the damaged area of the - window. Attempts to draw outside this area do not appear. + def DrawIcon(*args, **kwargs): + """ + DrawIcon(self, Icon icon, Double x, Double y, Double w, Double h) - To draw on a window from outside EVT_PAINT handlers, construct a - `wx.ClientDC` object. + Draws the icon. + """ + return _gdi_.GraphicsContext_DrawIcon(*args, **kwargs) - """ - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args, **kwargs): + def StrokeLine(*args, **kwargs): """ - __init__(self, Window win) -> PaintDC + StrokeLine(self, Double x1, Double y1, Double x2, Double y2) - Constructor. Pass the window on which you wish to paint. + Strokes a single line. """ - _gdi_.PaintDC_swiginit(self,_gdi_.new_PaintDC(*args, **kwargs)) -_gdi_.PaintDC_swigregister(PaintDC) + return _gdi_.GraphicsContext_StrokeLine(*args, **kwargs) -#--------------------------------------------------------------------------- + def StrokeLines(*args, **kwargs): + """ + StrokeLines(self, List points) -class WindowDC(DC): - """ - A wx.WindowDC must be constructed if an application wishes to paint on - the whole area of a window (client and decorations). This should - normally be constructed as a temporary stack object; don't store a - wx.WindowDC object. - """ - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args, **kwargs): + Stroke lines connecting each of the points """ - __init__(self, Window win) -> WindowDC + return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs) - Constructor. Pass the window on which you wish to paint. + def StrokeLineSegements(*args, **kwargs): """ - _gdi_.WindowDC_swiginit(self,_gdi_.new_WindowDC(*args, **kwargs)) -_gdi_.WindowDC_swigregister(WindowDC) + StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints) -#--------------------------------------------------------------------------- + Stroke disconnected lines from begin to end points + """ + return _gdi_.GraphicsContext_StrokeLineSegements(*args, **kwargs) -class MirrorDC(DC): - """ - wx.MirrorDC is a simple wrapper class which is always associated with a - real `wx.DC` object and either forwards all of its operations to it - without changes (no mirroring takes place) or exchanges x and y - coordinates which makes it possible to reuse the same code to draw a - figure and its mirror -- i.e. reflection related to the diagonal line - x == y. - """ - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args, **kwargs): + def DrawLines(*args, **kwargs): """ - __init__(self, DC dc, bool mirror) -> MirrorDC + DrawLines(self, size_t points, int fillStyle=ODDEVEN_RULE) - Creates a mirrored DC associated with the real *dc*. Everything drawn - on the wx.MirrorDC will appear on the *dc*, and will be mirrored if - *mirror* is True. + Draws a polygon. """ - _gdi_.MirrorDC_swiginit(self,_gdi_.new_MirrorDC(*args, **kwargs)) -_gdi_.MirrorDC_swigregister(MirrorDC) + return _gdi_.GraphicsContext_DrawLines(*args, **kwargs) -#--------------------------------------------------------------------------- + def DrawRectangle(*args, **kwargs): + """ + DrawRectangle(self, Double x, Double y, Double w, Double h) -class PostScriptDC(DC): - """This is a `wx.DC` that can write to PostScript files on any platform.""" - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args, **kwargs): + Draws a rectangle. """ - __init__(self, wxPrintData printData) -> PostScriptDC + return _gdi_.GraphicsContext_DrawRectangle(*args, **kwargs) - Constructs a PostScript printer device context from a `wx.PrintData` - object. + def DrawEllipse(*args, **kwargs): """ - _gdi_.PostScriptDC_swiginit(self,_gdi_.new_PostScriptDC(*args, **kwargs)) - def GetPrintData(*args, **kwargs): - """GetPrintData(self) -> wxPrintData""" - return _gdi_.PostScriptDC_GetPrintData(*args, **kwargs) + DrawEllipse(self, Double x, Double y, Double w, Double h) - def SetPrintData(*args, **kwargs): - """SetPrintData(self, wxPrintData data)""" - return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs) + Draws an ellipse. + """ + return _gdi_.GraphicsContext_DrawEllipse(*args, **kwargs) - def SetResolution(*args, **kwargs): + def DrawRoundedRectangle(*args, **kwargs): """ - SetResolution(int ppi) + DrawRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius) - Set resolution (in pixels per inch) that will be used in PostScript - output. Default is 720ppi. + Draws a rounded rectangle """ - return _gdi_.PostScriptDC_SetResolution(*args, **kwargs) + return _gdi_.GraphicsContext_DrawRoundedRectangle(*args, **kwargs) - SetResolution = staticmethod(SetResolution) - def GetResolution(*args, **kwargs): + def ShouldOffset(*args, **kwargs): """ - GetResolution() -> int + ShouldOffset(self) -> bool - Return resolution used in PostScript output. + helper to determine if a 0.5 offset should be applied for the drawing operation """ - return _gdi_.PostScriptDC_GetResolution(*args, **kwargs) + return _gdi_.GraphicsContext_ShouldOffset(*args, **kwargs) - GetResolution = staticmethod(GetResolution) -_gdi_.PostScriptDC_swigregister(PostScriptDC) +_gdi_.GraphicsContext_swigregister(GraphicsContext) +cvar = _gdi_.cvar +NullGraphicsPen = cvar.NullGraphicsPen +NullGraphicsBrush = cvar.NullGraphicsBrush +NullGraphicsFont = cvar.NullGraphicsFont +NullGraphicsMatrix = cvar.NullGraphicsMatrix +NullGraphicsPath = cvar.NullGraphicsPath -def PostScriptDC_SetResolution(*args, **kwargs): +def GraphicsContext_Create(*args): """ - PostScriptDC_SetResolution(int ppi) + Create(WindowDC dc) -> GraphicsContext + GraphicsContext_Create(Window window) -> GraphicsContext - Set resolution (in pixels per inch) that will be used in PostScript - output. Default is 720ppi. + Creates a wx.GraphicsContext either from a window or a DC. """ - return _gdi_.PostScriptDC_SetResolution(*args, **kwargs) + val = _gdi_.GraphicsContext_Create(*args) + val.__dc = args[0] # save a ref so the dc will not be deleted before self + return val -def PostScriptDC_GetResolution(*args): +def GraphicsContext_CreateMeasuringContext(*args): """ - PostScriptDC_GetResolution() -> int + GraphicsContext_CreateMeasuringContext() -> GraphicsContext - Return resolution used in PostScript output. + Create a lightwieght context that can be used for measuring text only. """ - return _gdi_.PostScriptDC_GetResolution(*args) + val = _gdi_.GraphicsContext_CreateMeasuringContext(*args) + val.__dc = args[0] # save a ref so the dc will not be deleted before self + return val -#--------------------------------------------------------------------------- +def GraphicsContext_CreateFromNative(*args, **kwargs): + """ + GraphicsContext_CreateFromNative(void context) -> GraphicsContext -class MetaFile(_core.Object): - """Proxy of C++ MetaFile class""" + Creates a wx.GraphicsContext from a native context. This native context + must be eg a CGContextRef for Core Graphics, a Graphics pointer for + GDIPlus or a cairo_t pointer for Cairo. + """ + return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs) + +def GraphicsContext_CreateFromNativeWindow(*args, **kwargs): + """ + GraphicsContext_CreateFromNativeWindow(void window) -> GraphicsContext + + Creates a wx.GraphicsContext from a native window. + """ + return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs) + +class GraphicsRenderer(_core.Object): + """Proxy of C++ GraphicsRenderer class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr - def __init__(self, *args, **kwargs): - """__init__(self, String filename=EmptyString) -> MetaFile""" - _gdi_.MetaFile_swiginit(self,_gdi_.new_MetaFile(*args, **kwargs)) - __swig_destroy__ = _gdi_.delete_MetaFile + __swig_destroy__ = _gdi_.delete_GraphicsRenderer __del__ = lambda self : None; - def Ok(*args, **kwargs): - """Ok(self) -> bool""" - return _gdi_.MetaFile_Ok(*args, **kwargs) + def GetDefaultRenderer(*args, **kwargs): + """GetDefaultRenderer() -> GraphicsRenderer""" + return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args, **kwargs) - def SetClipboard(*args, **kwargs): - """SetClipboard(self, int width=0, int height=0) -> bool""" - return _gdi_.MetaFile_SetClipboard(*args, **kwargs) + GetDefaultRenderer = staticmethod(GetDefaultRenderer) + def CreateContext(*args): + """ + CreateContext(self, WindowDC dc) -> GraphicsContext + CreateContext(self, Window window) -> GraphicsContext + """ + return _gdi_.GraphicsRenderer_CreateContext(*args) - def GetSize(*args, **kwargs): - """GetSize(self) -> Size""" - return _gdi_.MetaFile_GetSize(*args, **kwargs) + def CreateMeasuringContext(*args, **kwargs): + """CreateMeasuringContext(self) -> GraphicsContext""" + return _gdi_.GraphicsRenderer_CreateMeasuringContext(*args, **kwargs) - def GetWidth(*args, **kwargs): - """GetWidth(self) -> int""" - return _gdi_.MetaFile_GetWidth(*args, **kwargs) + def CreateContextFromNativeContext(*args, **kwargs): + """CreateContextFromNativeContext(self, void context) -> GraphicsContext""" + return _gdi_.GraphicsRenderer_CreateContextFromNativeContext(*args, **kwargs) - def GetHeight(*args, **kwargs): - """GetHeight(self) -> int""" - return _gdi_.MetaFile_GetHeight(*args, **kwargs) + def CreateContextFromNativeWindow(*args, **kwargs): + """CreateContextFromNativeWindow(self, void window) -> GraphicsContext""" + return _gdi_.GraphicsRenderer_CreateContextFromNativeWindow(*args, **kwargs) - def GetFileName(*args, **kwargs): - """GetFileName(self) -> String""" - return _gdi_.MetaFile_GetFileName(*args, **kwargs) + def CreatePath(*args, **kwargs): + """CreatePath(self) -> GraphicsPath""" + return _gdi_.GraphicsRenderer_CreatePath(*args, **kwargs) - def __nonzero__(self): return self.Ok() -_gdi_.MetaFile_swigregister(MetaFile) + def CreateMatrix(*args, **kwargs): + """ + CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, + Double tx=0.0, Double ty=0.0) -> GraphicsMatrix + """ + return _gdi_.GraphicsRenderer_CreateMatrix(*args, **kwargs) -class MetaFileDC(DC): - """Proxy of C++ MetaFileDC class""" + def CreatePen(*args, **kwargs): + """CreatePen(self, Pen pen) -> GraphicsPen""" + return _gdi_.GraphicsRenderer_CreatePen(*args, **kwargs) + + def CreateBrush(*args, **kwargs): + """CreateBrush(self, Brush brush) -> GraphicsBrush""" + return _gdi_.GraphicsRenderer_CreateBrush(*args, **kwargs) + + def CreateLinearGradientBrush(*args, **kwargs): + """ + CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1, + Colour c2) -> GraphicsBrush + """ + return _gdi_.GraphicsRenderer_CreateLinearGradientBrush(*args, **kwargs) + + def CreateRadialGradientBrush(*args, **kwargs): + """ + CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius, + Colour oColor, Colour cColor) -> GraphicsBrush + """ + return _gdi_.GraphicsRenderer_CreateRadialGradientBrush(*args, **kwargs) + + def CreateFont(*args, **kwargs): + """CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont""" + return _gdi_.GraphicsRenderer_CreateFont(*args, **kwargs) + +_gdi_.GraphicsRenderer_swigregister(GraphicsRenderer) + +def GraphicsRenderer_GetDefaultRenderer(*args): + """GraphicsRenderer_GetDefaultRenderer() -> GraphicsRenderer""" + return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args) + +class GCDC(DC): + """Proxy of C++ GCDC class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args, **kwargs): + def __init__(self, *args): """ - __init__(self, String filename=EmptyString, int width=0, int height=0, - String description=EmptyString) -> MetaFileDC + __init__(self, WindowDC dc) -> GCDC + __init__(self, Window window) -> GCDC """ - _gdi_.MetaFileDC_swiginit(self,_gdi_.new_MetaFileDC(*args, **kwargs)) - def Close(*args, **kwargs): - """Close(self) -> MetaFile""" - return _gdi_.MetaFileDC_Close(*args, **kwargs) + _gdi_.GCDC_swiginit(self,_gdi_.new_GCDC(*args)) + self.__dc = args[0] # save a ref so the other dc will not be deleted before self -_gdi_.MetaFileDC_swigregister(MetaFileDC) + __swig_destroy__ = _gdi_.delete_GCDC + __del__ = lambda self : None; + def GetGraphicsContext(*args, **kwargs): + """GetGraphicsContext(self) -> GraphicsContext""" + return _gdi_.GCDC_GetGraphicsContext(*args, **kwargs) -class PrinterDC(DC): - """Proxy of C++ PrinterDC class""" + def SetGraphicsContext(*args, **kwargs): + """SetGraphicsContext(self, GraphicsContext ctx)""" + return _gdi_.GCDC_SetGraphicsContext(*args, **kwargs) + + GraphicsContext = property(GetGraphicsContext,SetGraphicsContext) +_gdi_.GCDC_swigregister(GCDC) + +class Overlay(object): + """Proxy of C++ Overlay class""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): - """__init__(self, wxPrintData printData) -> PrinterDC""" - _gdi_.PrinterDC_swiginit(self,_gdi_.new_PrinterDC(*args, **kwargs)) -_gdi_.PrinterDC_swigregister(PrinterDC) + """__init__(self) -> Overlay""" + _gdi_.Overlay_swiginit(self,_gdi_.new_Overlay(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_Overlay + __del__ = lambda self : None; + def Reset(*args, **kwargs): + """Reset(self)""" + return _gdi_.Overlay_Reset(*args, **kwargs) + +_gdi_.Overlay_swigregister(Overlay) + +class DCOverlay(object): + """Proxy of C++ DCOverlay class""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(self, Overlay overlay, WindowDC dc, int x, int y, int width, + int height) -> DCOverlay + __init__(self, Overlay overlay, WindowDC dc) -> DCOverlay + """ + _gdi_.DCOverlay_swiginit(self,_gdi_.new_DCOverlay(*args)) + __swig_destroy__ = _gdi_.delete_DCOverlay + __del__ = lambda self : None; + def Clear(*args, **kwargs): + """Clear(self)""" + return _gdi_.DCOverlay_Clear(*args, **kwargs) + +_gdi_.DCOverlay_swigregister(DCOverlay) #--------------------------------------------------------------------------- @@ -4464,6 +6113,8 @@ class ImageList(_core.Object): """GetSize(index) -> (width,height)""" return _gdi_.ImageList_GetSize(*args, **kwargs) + ImageCount = property(GetImageCount,doc="See `GetImageCount`") + Size = property(GetSize,doc="See `GetSize`") _gdi_.ImageList_swigregister(ImageList) #--------------------------------------------------------------------------- @@ -4672,7 +6323,6 @@ class GDIObjListBase(object): __swig_destroy__ = _gdi_.delete_GDIObjListBase __del__ = lambda self : None; _gdi_.GDIObjListBase_swigregister(GDIObjListBase) -cvar = _gdi_.cvar NullBitmap = cvar.NullBitmap NullIcon = cvar.NullIcon NullCursor = cvar.NullCursor @@ -4870,6 +6520,11 @@ class Effects(_core.Object): """TileBitmap(self, Rect rect, DC dc, Bitmap bitmap) -> bool""" return _gdi_.Effects_TileBitmap(*args, **kwargs) + DarkShadow = property(GetDarkShadow,SetDarkShadow,doc="See `GetDarkShadow` and `SetDarkShadow`") + FaceColour = property(GetFaceColour,SetFaceColour,doc="See `GetFaceColour` and `SetFaceColour`") + HighlightColour = property(GetHighlightColour,SetHighlightColour,doc="See `GetHighlightColour` and `SetHighlightColour`") + LightShadow = property(GetLightShadow,SetLightShadow,doc="See `GetLightShadow` and `SetLightShadow`") + MediumShadow = property(GetMediumShadow,SetMediumShadow,doc="See `GetMediumShadow` and `SetMediumShadow`") _gdi_.Effects_swigregister(Effects) #--------------------------------------------------------------------------- @@ -4877,9 +6532,11 @@ _gdi_.Effects_swigregister(Effects) CONTROL_DISABLED = _gdi_.CONTROL_DISABLED CONTROL_FOCUSED = _gdi_.CONTROL_FOCUSED CONTROL_PRESSED = _gdi_.CONTROL_PRESSED +CONTROL_SPECIAL = _gdi_.CONTROL_SPECIAL CONTROL_ISDEFAULT = _gdi_.CONTROL_ISDEFAULT CONTROL_ISSUBMENU = _gdi_.CONTROL_ISSUBMENU CONTROL_EXPANDED = _gdi_.CONTROL_EXPANDED +CONTROL_SIZEGRIP = _gdi_.CONTROL_SIZEGRIP CONTROL_CURRENT = _gdi_.CONTROL_CURRENT CONTROL_SELECTED = _gdi_.CONTROL_SELECTED CONTROL_CHECKED = _gdi_.CONTROL_CHECKED @@ -4925,6 +6582,31 @@ class SplitterRenderParams(object): isHotSensitive = property(_gdi_.SplitterRenderParams_isHotSensitive_get) _gdi_.SplitterRenderParams_swigregister(SplitterRenderParams) +class HeaderButtonParams(object): + """Extra (optional) parameters for `wx.RendererNative.DrawHeaderButton`""" + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self) -> HeaderButtonParams + + Extra (optional) parameters for `wx.RendererNative.DrawHeaderButton` + """ + _gdi_.HeaderButtonParams_swiginit(self,_gdi_.new_HeaderButtonParams(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_HeaderButtonParams + __del__ = lambda self : None; + m_arrowColour = property(_gdi_.HeaderButtonParams_m_arrowColour_get, _gdi_.HeaderButtonParams_m_arrowColour_set) + m_selectionColour = property(_gdi_.HeaderButtonParams_m_selectionColour_get, _gdi_.HeaderButtonParams_m_selectionColour_set) + m_labelText = property(_gdi_.HeaderButtonParams_m_labelText_get, _gdi_.HeaderButtonParams_m_labelText_set) + m_labelFont = property(_gdi_.HeaderButtonParams_m_labelFont_get, _gdi_.HeaderButtonParams_m_labelFont_set) + m_labelColour = property(_gdi_.HeaderButtonParams_m_labelColour_get, _gdi_.HeaderButtonParams_m_labelColour_set) + m_labelBitmap = property(_gdi_.HeaderButtonParams_m_labelBitmap_get, _gdi_.HeaderButtonParams_m_labelBitmap_set) + m_labelAlignment = property(_gdi_.HeaderButtonParams_m_labelAlignment_get, _gdi_.HeaderButtonParams_m_labelAlignment_set) +_gdi_.HeaderButtonParams_swigregister(HeaderButtonParams) + +HDR_SORT_ICON_NONE = _gdi_.HDR_SORT_ICON_NONE +HDR_SORT_ICON_UP = _gdi_.HDR_SORT_ICON_UP +HDR_SORT_ICON_DOWN = _gdi_.HDR_SORT_ICON_DOWN class RendererVersion(object): """ This simple struct represents the `wx.RendererNative` interface @@ -4961,11 +6643,12 @@ def RendererVersion_IsCompatible(*args, **kwargs): class RendererNative(object): """ - One of the design principles of wxWidgets is to use the native widgets - on every platform in order to be as close to the native look and feel - on every platform. However there are still cases when some generic - widgets are needed for various reasons, but it can sometimes take a - lot of messy work to make them conform to the native LnF. + One of the design principles of wxWidgets is to use the native + widgets on every platform in order to be as close as possible to + the native look and feel on every platform. However there are + still cases when some generic widgets are needed for various + reasons, but it can sometimes take a lot of messy work to make + them conform to the native LnF. The wx.RendererNative class is a collection of functions that have platform-specific implementations for drawing certain parts of @@ -4983,13 +6666,33 @@ class RendererNative(object): __repr__ = _swig_repr def DrawHeaderButton(*args, **kwargs): """ - DrawHeaderButton(self, Window win, DC dc, Rect rect, int flags=0) + DrawHeaderButton(self, Window win, DC dc, Rect rect, int flags=0, int sortArrow=HDR_SORT_ICON_NONE, + HeaderButtonParams params=None) Draw the header control button (such as what is used by `wx.ListCtrl` in report mode.) """ return _gdi_.RendererNative_DrawHeaderButton(*args, **kwargs) + def DrawHeaderButtonContents(*args, **kwargs): + """ + DrawHeaderButtonContents(self, Window win, DC dc, Rect rect, int flags=0, int sortArrow=HDR_SORT_ICON_NONE, + HeaderButtonParams params=None) + + Draw the contents of a header control button, (label, sort + arrows, etc.) Normally this is only called by `DrawHeaderButton`. + """ + return _gdi_.RendererNative_DrawHeaderButtonContents(*args, **kwargs) + + def GetHeaderButtonHeight(*args, **kwargs): + """ + GetHeaderButtonHeight(self, Window win) -> int + + Returns the default height of a header button, either a fixed platform + height if available, or a generic height based on the window's font. + """ + return _gdi_.RendererNative_GetHeaderButtonHeight(*args, **kwargs) + def DrawTreeItemButton(*args, **kwargs): """ DrawTreeItemButton(self, Window win, DC dc, Rect rect, int flags=0) @@ -5104,7 +6807,7 @@ class RendererNative(object): Return the generic implementation of the renderer. Under some platforms, this is the default renderer implementation, others have platform-specific default renderer which can be retrieved by calling - `GetDefault`. + `wx.RendererNative.GetDefault`. """ return _gdi_.RendererNative_GetGeneric(*args, **kwargs) @@ -5114,9 +6817,9 @@ class RendererNative(object): GetDefault() -> RendererNative Return the default (native) implementation for this platform -- this - is also the one used by default but this may be changed by calling `Set` - in which case the return value of this method may be different from - the return value of `Get`. + is also the one used by default but this may be changed by calling + `wx.RendererNative.Set` in which case the return value of this method + may be different from the return value of `wx.RendererNative.Get`. """ return _gdi_.RendererNative_GetDefault(*args, **kwargs) @@ -5140,6 +6843,8 @@ class RendererNative(object): """ return _gdi_.RendererNative_GetVersion(*args, **kwargs) + SplitterParams = property(GetSplitterParams,doc="See `GetSplitterParams`") + Version = property(GetVersion,doc="See `GetVersion`") _gdi_.RendererNative_swigregister(RendererNative) def RendererNative_Get(*args): @@ -5157,7 +6862,7 @@ def RendererNative_GetGeneric(*args): Return the generic implementation of the renderer. Under some platforms, this is the default renderer implementation, others have platform-specific default renderer which can be retrieved by calling - `GetDefault`. + `wx.RendererNative.GetDefault`. """ return _gdi_.RendererNative_GetGeneric(*args) @@ -5166,9 +6871,9 @@ def RendererNative_GetDefault(*args): RendererNative_GetDefault() -> RendererNative Return the default (native) implementation for this platform -- this - is also the one used by default but this may be changed by calling `Set` - in which case the return value of this method may be different from - the return value of `Get`. + is also the one used by default but this may be changed by calling + `wx.RendererNative.Set` in which case the return value of this method + may be different from the return value of `wx.RendererNative.Get`. """ return _gdi_.RendererNative_GetDefault(*args) @@ -5273,6 +6978,43 @@ class PseudoDC(_core.Object): """ return _gdi_.PseudoDC_TranslateId(*args, **kwargs) + def SetIdGreyedOut(*args, **kwargs): + """ + SetIdGreyedOut(self, int id, bool greyout=True) + + Set whether an object is drawn greyed out or not. + """ + return _gdi_.PseudoDC_SetIdGreyedOut(*args, **kwargs) + + def GetIdGreyedOut(*args, **kwargs): + """ + GetIdGreyedOut(self, int id) -> bool + + Get whether an object is drawn greyed out or not. + """ + return _gdi_.PseudoDC_GetIdGreyedOut(*args, **kwargs) + + def FindObjects(*args, **kwargs): + """ + FindObjects(self, int x, int y, int radius=1, wxColor bg=*wxWHITE) -> PyObject + + Returns a list of all the id's that draw a pixel with color + not equal to bg within radius of (x,y). + Returns an empty list if nothing is found. The list is in + reverse drawing order so list[0] is the top id. + """ + return _gdi_.PseudoDC_FindObjects(*args, **kwargs) + + def FindObjectsByBBox(*args, **kwargs): + """ + FindObjectsByBBox(self, int x, int y) -> PyObject + + Returns a list of all the id's whose bounding boxes include (x,y). + Returns an empty list if nothing is found. The list is in + reverse drawing order so list[0] is the top id. + """ + return _gdi_.PseudoDC_FindObjectsByBBox(*args, **kwargs) + def DrawIdToDC(*args, **kwargs): """ DrawIdToDC(self, int id, DC dc) @@ -5680,8 +7422,10 @@ class PseudoDC(_core.Object): font, and the current text foreground and background colours. The coordinates refer to the top-left corner of the rectangle bounding - the string. See `GetTextExtent` for how to get the dimensions of a - text string, which can be used to position the text more precisely. + the string. See `wx.DC.GetTextExtent` for how to get the dimensions of + a text string, which can be used to position the text more precisely, + (you will need to use a real DC with GetTextExtent as wx.PseudoDC does + not implement it.) **NOTE**: under wxGTK the current logical function is used by this function but it is ignored by wxMSW. Thus, you should avoid using @@ -5697,8 +7441,10 @@ class PseudoDC(_core.Object): font, and the current text foreground and background colours. The coordinates refer to the top-left corner of the rectangle bounding - the string. See `GetTextExtent` for how to get the dimensions of a - text string, which can be used to position the text more precisely. + the string. See `wx.DC.GetTextExtent` for how to get the dimensions of + a text string, which can be used to position the text more precisely, + (you will need to use a real DC with GetTextExtent as wx.PseudoDC does + not implement it.) **NOTE**: under wxGTK the current logical function is used by this function but it is ignored by wxMSW. Thus, you should avoid using @@ -5881,9 +7627,8 @@ class PseudoDC(_core.Object): SetLogicalFunction(self, int function) Sets the current logical function for the device context. This - determines how a source pixel (from a pen or brush colour, or source - device context if using `Blit`) combines with a destination pixel in - the current device context. + determines how a source pixel (from a pen or brush colour, combines + with a destination pixel in the current device context. The possible values and their meaning in terms of source and destination pixel values are as follows: @@ -5916,6 +7661,8 @@ class PseudoDC(_core.Object): """ return _gdi_.PseudoDC_SetLogicalFunction(*args, **kwargs) + IdBounds = property(GetIdBounds,SetIdBounds,doc="See `GetIdBounds` and `SetIdBounds`") + Len = property(GetLen,doc="See `GetLen`") _gdi_.PseudoDC_swigregister(PseudoDC)