X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/6a223074d30c2ec81b688f2c0f14845fdaa4da81..9e477492e29e03c02827b1e42a16cb09a13f5149:/wxPython/src/msw/_gdi.py?ds=inline diff --git a/wxPython/src/msw/_gdi.py b/wxPython/src/msw/_gdi.py index 5696b7c0ce..8d32f4ed97 100644 --- a/wxPython/src/msw/_gdi.py +++ b/wxPython/src/msw/_gdi.py @@ -146,15 +146,16 @@ class Colour(_core.Object): """ return _gdi_.Colour_Alpha(*args, **kwargs) - def Ok(*args, **kwargs): + def IsOk(*args, **kwargs): """ - Ok(self) -> bool + 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, byte alpha=ALPHA_OPAQUE) @@ -239,7 +240,9 @@ class Colour(_core.Object): asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead") def __str__(self): return str(self.Get(True)) def __repr__(self): return 'wx.Colour' + str(self.Get(True)) - def __nonzero__(self): return self.Ok() + 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(True)) @@ -291,11 +294,12 @@ 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) @@ -330,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) @@ -394,7 +399,7 @@ 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`") @@ -481,15 +486,16 @@ 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`") @@ -532,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 @@ -686,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) @@ -1136,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) @@ -1172,7 +1198,7 @@ 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`") @@ -1211,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) @@ -1307,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) @@ -1420,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) @@ -1976,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) @@ -2374,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): @@ -2841,7 +2873,7 @@ class PyLocale(Locale): 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)) - self._setCallbackInfo(self, PyLocale) + PyLocale._setCallbackInfo(self, self, PyLocale) __swig_destroy__ = _gdi_.delete_PyLocale __del__ = lambda self : None; @@ -2936,7 +2968,7 @@ def EncodingConverter_CanConvert(*args, **kwargs): # to the default catalog path. if wx.Platform == "__WXMSW__": import os - _localedir = os.path.join(os.path.split(__file__)[0], "i18n") + _localedir = os.path.join(os.path.split(__file__)[0], "locale") Locale.AddCatalogLookupPathPrefix(_localedir) del os @@ -3442,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) @@ -3736,7 +3772,7 @@ class DC(_core.Object): GetMultiLineTextExtent(wxString string, Font font=None) -> (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. """ @@ -3907,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 @@ -4217,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) @@ -4436,151 +4493,90 @@ class DC(_core.Object): 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. - - 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): - """ - 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. + __init__(self, DC dc, Colour col) -> 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. + wx.DCTextColourChanger can be used to temporarily change the DC text + colour and restore it automatically when the object goes out of scope """ - return _gdi_.MemoryDC_SelectObject(*args, **kwargs) - -_gdi_.MemoryDC_swigregister(MemoryDC) + _gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCTextColourChanger + __del__ = lambda self : None; +_gdi_.DCTextColourChanger_swigregister(DCTextColourChanger) -def MemoryDCFromDC(*args, **kwargs): +class DCPenChanger(object): """ - MemoryDCFromDC(DC oldDC) -> MemoryDC - - Creates a DC that is compatible with the oldDC. + wx.DCPenChanger can be used to temporarily change the DC pen 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, Pen pen) -> DCPenChanger -#--------------------------------------------------------------------------- + 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) -BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA -BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA -class BufferedDC(MemoryDC): +class DCBrushChanger(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`. - - Please note that GTK+ 2.0 and OS X provide double buffering themselves - natively so using this class on those platforms will normally result - in an unneeded level of buffering. - + wx.DCBrushChanger can be used to temporarily change the DC brush 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): + def __init__(self, *args, **kwargs): """ - __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, Brush brush) -> DCBrushChanger - Constructs a buffered DC. + wx.DCBrushChanger can be used to temporarily change the DC brush and + restore it automatically when the object 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_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCBrushChanger __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_.BufferedDC_swigregister(BufferedDC) +_gdi_.DCBrushChanger_swigregister(DCBrushChanger) -class BufferedPaintDC(BufferedDC): +class DCClipper(object): """ - 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) - - - - - + 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, **kwargs): + def __init__(self, *args): """ - __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). - + __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 + 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_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs)) -_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC) + _gdi_.DCClipper_swiginit(self,_gdi_.new_DCClipper(*args)) + __swig_destroy__ = _gdi_.delete_DCClipper + __del__ = lambda self : None; +_gdi_.DCClipper_swigregister(DCClipper) #--------------------------------------------------------------------------- @@ -4648,7 +4644,27 @@ _gdi_.ScreenDC_swigregister(ScreenDC) #--------------------------------------------------------------------------- -class ClientDC(DC): +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 @@ -4675,7 +4691,7 @@ _gdi_.ClientDC_swigregister(ClientDC) #--------------------------------------------------------------------------- -class PaintDC(DC): +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 @@ -4705,171 +4721,1362 @@ _gdi_.PaintDC_swigregister(PaintDC) #--------------------------------------------------------------------------- -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. +class MemoryDC(WindowDC): """ - 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 + 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:: - Constructor. Pass the window on which you wish to paint. - """ - _gdi_.WindowDC_swiginit(self,_gdi_.new_WindowDC(*args, **kwargs)) -_gdi_.WindowDC_swigregister(WindowDC) + 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. -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) + __init__(self, Bitmap bitmap=NullBitmap) -> MemoryDC -#--------------------------------------------------------------------------- + Constructs a new memory device context. -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): + 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. """ - __init__(self, wxPrintData printData) -> PostScriptDC - - Constructs a PostScript printer device context from a `wx.PrintData` - object. + _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs)) + def SelectObject(*args, **kwargs): """ - _gdi_.PostScriptDC_swiginit(self,_gdi_.new_PostScriptDC(*args, **kwargs)) - def GetPrintData(*args, **kwargs): - """GetPrintData(self) -> wxPrintData""" - return _gdi_.PostScriptDC_GetPrintData(*args, **kwargs) + SelectObject(self, Bitmap bitmap) - def SetPrintData(*args, **kwargs): - """SetPrintData(self, wxPrintData data)""" - return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs) + 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. - def SetResolution(*args, **kwargs): + 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. """ - SetResolution(int ppi) + return _gdi_.MemoryDC_SelectObject(*args, **kwargs) - Set resolution (in pixels per inch) that will be used in PostScript - output. Default is 720ppi. - """ - return _gdi_.PostScriptDC_SetResolution(*args, **kwargs) + def SelectObjectAsSource(*args, **kwargs): + """SelectObjectAsSource(self, Bitmap bmp)""" + return _gdi_.MemoryDC_SelectObjectAsSource(*args, **kwargs) - SetResolution = staticmethod(SetResolution) - def GetResolution(*args, **kwargs): - """ - GetResolution() -> int +_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)) + # save a ref so the other dc will not be deleted before self + self.__dc = args[0] + # also save a ref to the bitmap + if len(args) > 1: self.__bmp = args[1] + + + __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)) + if len(args) > 1: self.__bmp = args[1] + +_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 Get(*args, **kwargs): + """ + Get(self) --> (a, b, c, d, tx, ty) + + Gets the component values of the matrix and returns them as a tuple. + """ + return _gdi_.GraphicsMatrix_Get(*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) -> Rect2D + + 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, Point2D 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) - Return resolution used in PostScript output. + def Clip(*args, **kwargs): """ - return _gdi_.PostScriptDC_GetResolution(*args, **kwargs) + Clip(self, Double x, Double y, Double w, Double h) - GetResolution = staticmethod(GetResolution) - PrintData = property(GetPrintData,SetPrintData,doc="See `GetPrintData` and `SetPrintData`") -_gdi_.PostScriptDC_swigregister(PostScriptDC) + Clips drawings to the rectangle. + """ + return _gdi_.GraphicsContext_Clip(*args, **kwargs) -def PostScriptDC_SetResolution(*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 GetLogicalFunction(*args, **kwargs): + """ + GetLogicalFunction(self) -> int + + Returns the current logical function. + """ + return _gdi_.GraphicsContext_GetLogicalFunction(*args, **kwargs) + + def SetLogicalFunction(*args, **kwargs): + """ + SetLogicalFunction(self, int function) -> bool + + Sets the current logical function, returns ``True`` if it supported + """ + return _gdi_.GraphicsContext_SetLogicalFunction(*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) + + 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) + + 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) + + def GetTextExtent(*args, **kwargs): + """ + GetTextExtent(self, text) --> (width, height) + + 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) + + def GetPartialTextExtents(*args, **kwargs): + """ + GetPartialTextExtents(self, text) -> [widths] + + Returns a list of widths from the beginning of ``text`` to the + coresponding character in ``text``. + """ + return _gdi_.GraphicsContext_GetPartialTextExtents(*args, **kwargs) + + def DrawBitmap(*args, **kwargs): + """ + DrawBitmap(self, Bitmap bmp, Double x, Double y, Double w, Double h) + + 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) + + def DrawIcon(*args, **kwargs): + """ + DrawIcon(self, Icon icon, Double x, Double y, Double w, Double h) + + Draws the icon. + """ + return _gdi_.GraphicsContext_DrawIcon(*args, **kwargs) + + def StrokeLine(*args, **kwargs): + """ + StrokeLine(self, Double x1, Double y1, Double x2, Double y2) + + Strokes a single line. + """ + return _gdi_.GraphicsContext_StrokeLine(*args, **kwargs) + + def StrokeLines(*args, **kwargs): + """ + StrokeLines(self, List points) + + Stroke lines connecting each of the points + """ + return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs) + + def StrokeLineSegements(*args, **kwargs): + """ + StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints) + + Stroke disconnected lines from begin to end points + """ + return _gdi_.GraphicsContext_StrokeLineSegements(*args, **kwargs) + + def DrawLines(*args, **kwargs): + """ + DrawLines(self, size_t points, int fillStyle=ODDEVEN_RULE) + + Draws a polygon. + """ + return _gdi_.GraphicsContext_DrawLines(*args, **kwargs) + + def DrawRectangle(*args, **kwargs): + """ + DrawRectangle(self, Double x, Double y, Double w, Double h) + + Draws a rectangle. + """ + return _gdi_.GraphicsContext_DrawRectangle(*args, **kwargs) + + def DrawEllipse(*args, **kwargs): + """ + DrawEllipse(self, Double x, Double y, Double w, Double h) + + Draws an ellipse. + """ + return _gdi_.GraphicsContext_DrawEllipse(*args, **kwargs) + + def DrawRoundedRectangle(*args, **kwargs): + """ + DrawRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius) + + Draws a rounded rectangle + """ + return _gdi_.GraphicsContext_DrawRoundedRectangle(*args, **kwargs) + + def ShouldOffset(*args, **kwargs): + """ + ShouldOffset(self) -> bool + + helper to determine if a 0.5 offset should be applied for the drawing operation + """ + return _gdi_.GraphicsContext_ShouldOffset(*args, **kwargs) + +_gdi_.GraphicsContext_swigregister(GraphicsContext) +cvar = _gdi_.cvar +NullGraphicsPen = cvar.NullGraphicsPen +NullGraphicsBrush = cvar.NullGraphicsBrush +NullGraphicsFont = cvar.NullGraphicsFont +NullGraphicsMatrix = cvar.NullGraphicsMatrix +NullGraphicsPath = cvar.NullGraphicsPath + +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) #--------------------------------------------------------------------------- @@ -5146,7 +6353,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 @@ -5356,9 +6562,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 @@ -5489,17 +6697,17 @@ class RendererNative(object): def DrawHeaderButton(*args, **kwargs): """ DrawHeaderButton(self, Window win, DC dc, Rect rect, int flags=0, int sortArrow=HDR_SORT_ICON_NONE, - HeaderButtonParams params=None) + HeaderButtonParams params=None) -> int - Draw the header control button (such as what is used by `wx.ListCtrl` - in report mode.) + Draw a header control button (such as what is used by `wx.ListCtrl` in report + mode.) The optimal size of the label (text and icons) is returned. """ 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) + HeaderButtonParams params=None) -> int Draw the contents of a header control button, (label, sort arrows, etc.) Normally this is only called by `DrawHeaderButton`. @@ -5800,6 +7008,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)