X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ac5d357a442f162b51c3ede0e2f702ad3ffe4406..5eb8189c35a0106b0741f28417bef238bbc9390f:/wxPython/src/mac/_gdi.py diff --git a/wxPython/src/mac/_gdi.py b/wxPython/src/mac/_gdi.py index 5f1f534746..ce9847fafa 100644 --- a/wxPython/src/mac/_gdi.py +++ b/wxPython/src/mac/_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,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) #--------------------------------------------------------------------------- @@ -329,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) @@ -379,7 +385,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,14 +472,15 @@ 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) + Ok = IsOk def MacGetTheme(*args, **kwargs): """MacGetTheme(self) -> short""" return _gdi_.Brush_MacGetTheme(*args, **kwargs) @@ -476,7 +489,7 @@ class Brush(GDIObject): """MacSetTheme(self, short macThemeBrush)""" return _gdi_.Brush_MacSetTheme(*args, **kwargs) - def __nonzero__(self): return self.Ok() + 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`") @@ -511,10 +524,11 @@ class Bitmap(GDIObject): _gdi_.Bitmap_swiginit(self,_gdi_.new_Bitmap(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_Bitmap __del__ = lambda self : None; - 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 @@ -657,7 +671,25 @@ class Bitmap(GDIObject): """ return _gdi_.Bitmap_SetSize(*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) @@ -817,6 +849,11 @@ class PixelDataBase(object): """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): @@ -1090,10 +1127,11 @@ class Icon(GDIObject): _gdi_.Icon_swiginit(self,_gdi_.new_Icon(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_Icon __del__ = lambda self : None; - 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) @@ -1122,7 +1160,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`") @@ -1161,7 +1199,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) @@ -1241,11 +1279,12 @@ class Cursor(GDIObject): _gdi_.Cursor_swiginit(self,_gdi_.new_Cursor(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_Cursor __del__ = lambda self : None; - 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() _gdi_.Cursor_swigregister(Cursor) def StockCursor(*args, **kwargs): @@ -1326,6 +1365,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) @@ -1374,6 +1417,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): @@ -1444,6 +1488,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) #--------------------------------------------------------------------------- @@ -1667,6 +1718,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): @@ -1859,15 +1917,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) @@ -2314,9 +2373,6 @@ def FontEnumerator_IsValidFacename(*args, **kwargs): #--------------------------------------------------------------------------- -Layout_Default = _gdi_.Layout_Default -Layout_LeftToRight = _gdi_.Layout_LeftToRight -Layout_RightToLeft = _gdi_.Layout_RightToLeft LANGUAGE_DEFAULT = _gdi_.LANGUAGE_DEFAULT LANGUAGE_UNKNOWN = _gdi_.LANGUAGE_UNKNOWN LANGUAGE_ABKHAZIAN = _gdi_.LANGUAGE_ABKHAZIAN @@ -2639,6 +2695,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) @@ -2695,6 +2756,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) @@ -2813,7 +2878,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 @@ -3319,6 +3384,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) @@ -3613,7 +3682,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. """ @@ -3784,14 +3853,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 @@ -4094,7 +4164,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 _DrawPointList(*args, **kwargs): """_DrawPointList(self, PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject""" return _gdi_.DC__DrawPointList(*args, **kwargs) @@ -4309,10 +4399,93 @@ 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 DCTextColourChanger(object): + """ + 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, DC dc, Colour col) -> DCTextColourChanger + + wx.DCTextColourChanger can be used to temporarily change the DC text + colour and restore it automatically when the object goes out of scope + """ + _gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs)) + __swig_destroy__ = _gdi_.delete_DCTextColourChanger + __del__ = lambda self : None; +_gdi_.DCTextColourChanger_swigregister(DCTextColourChanger) + +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): + """ + __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) + +class DCBrushChanger(object): + """ + 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, **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) + +class DCClipper(object): + """ + 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, 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_.DCClipper_swiginit(self,_gdi_.new_DCClipper(*args)) + __swig_destroy__ = _gdi_.delete_DCClipper + __del__ = lambda self : None; +_gdi_.DCClipper_swigregister(DCClipper) + +#--------------------------------------------------------------------------- + class MemoryDC(DC): """ A memory device context provides a means to draw graphics onto a @@ -4321,7 +4494,7 @@ class MemoryDC(DC): dc = wx.MemoryDC() dc.SelectObject(bitmap) - # draw on the dc usign any of the Draw methods + # draw on the dc using any of the Draw methods dc.SelectObject(wx.NullBitmap) # the bitmap now contains wahtever was drawn upon it @@ -4333,13 +4506,14 @@ class MemoryDC(DC): __repr__ = _swig_repr def __init__(self, *args, **kwargs): """ - __init__(self) -> MemoryDC + __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. Don't forget to select a bitmap into - the DC before drawing on it. + 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): @@ -4358,6 +4532,10 @@ class MemoryDC(DC): """ 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): @@ -4371,88 +4549,6 @@ def MemoryDCFromDC(*args, **kwargs): #--------------------------------------------------------------------------- -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. - - 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`. - - """ - 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) - -_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): """ A wxScreenDC can be used to paint anywhere on the screen. This should @@ -4517,7 +4613,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 @@ -4544,7 +4660,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 @@ -4574,57 +4690,174 @@ _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. +BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA +BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA +class BufferedDC(MemoryDC): """ - 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 + 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. - Constructor. Pass the window on which you wish to paint. - """ - _gdi_.WindowDC_swiginit(self,_gdi_.new_WindowDC(*args, **kwargs)) -_gdi_.WindowDC_swigregister(WindowDC) -#--------------------------------------------------------------------------- -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 __init__(self, *args): """ - __init__(self, DC dc, bool mirror) -> MirrorDC + __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 - 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. + Constructs a buffered DC. """ - _gdi_.MirrorDC_swiginit(self,_gdi_.new_MirrorDC(*args, **kwargs)) -_gdi_.MirrorDC_swigregister(MirrorDC) + _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) -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): + 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. """ - __init__(self, wxPrintData printData) -> PostScriptDC + 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. @@ -4657,6 +4890,7 @@ class PostScriptDC(DC): 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): @@ -4687,10 +4921,11 @@ class MetaFile(_core.Object): _gdi_.MetaFile_swiginit(self,_gdi_.new_MetaFile(*args, **kwargs)) __swig_destroy__ = _gdi_.delete_MetaFile __del__ = lambda self : None; - def Ok(*args, **kwargs): - """Ok(self) -> bool""" - return _gdi_.MetaFile_Ok(*args, **kwargs) + 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) @@ -4707,7 +4942,7 @@ class MetaFile(_core.Object): """GetHeight(self) -> int""" return _gdi_.MetaFile_GetHeight(*args, **kwargs) - def __nonzero__(self): return self.Ok() + def __nonzero__(self): return self.IsOk() _gdi_.MetaFile_swigregister(MetaFile) class MetaFileDC(DC): @@ -4737,6 +4972,806 @@ _gdi_.PrinterDC_swigregister(PrinterDC) #--------------------------------------------------------------------------- +class GraphicsObject(_core.Object): + """Proxy of C++ GraphicsObject 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, GraphicsRenderer renderer=None) -> GraphicsObject""" + _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""" + return _gdi_.GraphicsObject_IsNull(*args, **kwargs) + + def GetRenderer(*args, **kwargs): + """GetRenderer(self) -> GraphicsRenderer""" + return _gdi_.GraphicsObject_GetRenderer(*args, **kwargs) + +_gdi_.GraphicsObject_swigregister(GraphicsObject) + +class GraphicsPen(GraphicsObject): + """Proxy of C++ GraphicsPen 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) -> GraphicsPen""" + _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): + """Proxy of C++ GraphicsBrush 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) -> GraphicsBrush""" + _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): + """Proxy of C++ GraphicsFont 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) -> GraphicsFont""" + _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): + """Proxy of C++ GraphicsMatrix 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) -> GraphicsMatrix""" + _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 matrix + """ + return _gdi_.GraphicsMatrix_Concat(*args, **kwargs) + + def Copy(*args, **kwargs): + """ + Copy(self, GraphicsMatrix t) + + Copy the passed in matrix to this one. + """ + return _gdi_.GraphicsMatrix_Copy(*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 respective values + """ + return _gdi_.GraphicsMatrix_Set(*args, **kwargs) + + def Invert(*args, **kwargs): + """ + Invert(self) + + makes this the inverse 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 + + return true if this is the identity matrix + """ + return _gdi_.GraphicsMatrix_IsIdentity(*args, **kwargs) + + def Translate(*args, **kwargs): + """ + Translate(self, Double dx, Double dy) + + add the translation to this matrix + """ + return _gdi_.GraphicsMatrix_Translate(*args, **kwargs) + + def Scale(*args, **kwargs): + """ + Scale(self, Double xScale, Double yScale) + + add the scale to this matrix + """ + return _gdi_.GraphicsMatrix_Scale(*args, **kwargs) + + def Rotate(*args, **kwargs): + """ + Rotate(self, Double angle) + + add the rotation to this matrix (radians) + """ + return _gdi_.GraphicsMatrix_Rotate(*args, **kwargs) + + def TransformPoint(*args, **kwargs): + """ + TransformPoint(self, x, y) --> (x, y) + + applies that matrix to the point + """ + return _gdi_.GraphicsMatrix_TransformPoint(*args, **kwargs) + + def TransformDistance(*args, **kwargs): + """ + TransformDistance(self, dx, dy) --> (dx, dy) + + applies the matrix except for translations + """ + return _gdi_.GraphicsMatrix_TransformDistance(*args, **kwargs) + + def GetNativeMatrix(*args, **kwargs): + """ + GetNativeMatrix(self) -> void + + returns the native representation + """ + 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 (x,y) + """ + 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 (x,y) + """ + 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 as a new closed subpath with the given radius. + """ + return _gdi_.GraphicsPath_AddCircle(*args, **kwargs) + + def AddArcToPoint(*args, **kwargs): + """ + AddArcToPoint(self, Double x1, Double y1, Double x2, Double y2, Double r) + + Draws a 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 + """ + 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 + """ + return _gdi_.GraphicsPath_GetNativePath(*args, **kwargs) + + def UnGetNativePath(*args, **kwargs): + """ + UnGetNativePath(self, void p) + + give the native path returned by GetNativePath() back (there might be some + deallocations necessary) + """ + 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 + """ + return _gdi_.GraphicsPath_Contains(*args) + +_gdi_.GraphicsPath_swigregister(GraphicsPath) + +class GraphicsContext(GraphicsObject): + """Proxy of C++ GraphicsContext 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 + __swig_destroy__ = _gdi_.delete_GraphicsContext + __del__ = lambda self : None; + def Create(*args): + """ + Create(WindowDC dc) -> GraphicsContext + Create(Window window) -> GraphicsContext + """ + 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 CreateFromNative(*args, **kwargs): + """CreateFromNative(void context) -> GraphicsContext""" + return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs) + + CreateFromNative = staticmethod(CreateFromNative) + def CreateFromNativeWindow(*args, **kwargs): + """CreateFromNativeWindow(void window) -> GraphicsContext""" + return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs) + + CreateFromNativeWindow = staticmethod(CreateFromNativeWindow) + def CreatePath(*args, **kwargs): + """ + CreatePath(self) -> GraphicsPath + + creates a path instance that corresponds to the type of graphics context, ie GDIPlus, Cairo, CoreGraphics ... + """ + return _gdi_.GraphicsContext_CreatePath(*args, **kwargs) + + def CreatePen(*args, **kwargs): + """CreatePen(self, Pen pen) -> GraphicsPen""" + return _gdi_.GraphicsContext_CreatePen(*args, **kwargs) + + def CreateBrush(*args, **kwargs): + """CreateBrush(self, Brush brush) -> GraphicsBrush""" + 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 + + sets the brush to 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 + + sets the brush to a radial gradient originating at (xo,yc) with color + oColor and ends on a circle around (xc,yc) with radius r and color + cColor + + """ + return _gdi_.GraphicsContext_CreateRadialGradientBrush(*args, **kwargs) + + def CreateFont(*args, **kwargs): + """ + CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont + + sets the font + """ + 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 + + create a 'native' matrix corresponding to these values + """ + 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 + """ + return _gdi_.GraphicsContext_ClipRegion(*args, **kwargs) + + def Clip(*args, **kwargs): + """ + Clip(self, Double x, Double y, Double w, Double h) + + clips drawings to the rect + """ + return _gdi_.GraphicsContext_Clip(*args, **kwargs) + + def ResetClip(*args, **kwargs): + """ + ResetClip(self) + + resets the clipping to original extent + """ + return _gdi_.GraphicsContext_ResetClip(*args, **kwargs) + + def GetNativeContext(*args, **kwargs): + """ + GetNativeContext(self) -> void + + returns the native context + """ + return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs) + + def Translate(*args, **kwargs): + """ + Translate(self, Double dx, Double dy) + + translate the current transformation matrix CTM of the context + """ + return _gdi_.GraphicsContext_Translate(*args, **kwargs) + + def Scale(*args, **kwargs): + """ + Scale(self, Double xScale, Double yScale) + + scale the current transformation matrix CTM of the context + """ + return _gdi_.GraphicsContext_Scale(*args, **kwargs) + + def Rotate(*args, **kwargs): + """ + Rotate(self, Double angle) + + rotate (radians) the current transformation matrix CTM of the context + """ + return _gdi_.GraphicsContext_Rotate(*args, **kwargs) + + def ConcatTransform(*args, **kwargs): + """ + ConcatTransform(self, GraphicsMatrix matrix) + + concatenates this transform with the current transform of this context + """ + return _gdi_.GraphicsContext_ConcatTransform(*args, **kwargs) + + def SetTransform(*args, **kwargs): + """ + SetTransform(self, GraphicsMatrix matrix) + + sets the transform of this context + """ + return _gdi_.GraphicsContext_SetTransform(*args, **kwargs) + + def GetTransform(*args, **kwargs): + """ + GetTransform(self) -> GraphicsMatrix + + gets the 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 a 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)""" + return _gdi_.GraphicsContext_DrawText(*args, **kwargs) + + def DrawRotatedText(*args, **kwargs): + """DrawRotatedText(self, String str, Double x, Double y, Double angle)""" + return _gdi_.GraphicsContext_DrawRotatedText(*args, **kwargs) + + def GetFullTextExtent(*args, **kwargs): + """GetFullTextExtent(self, text) --> (width, height, descent, externalLeading)""" + return _gdi_.GraphicsContext_GetFullTextExtent(*args, **kwargs) + + def GetTextExtent(*args, **kwargs): + """GetTextExtent(self, text) --> (width, height)""" + return _gdi_.GraphicsContext_GetTextExtent(*args, **kwargs) + + def GetPartialTextExtents(*args, **kwargs): + """GetPartialTextExtents(self, text) -> [widths]""" + return _gdi_.GraphicsContext_GetPartialTextExtents(*args, **kwargs) + + def DrawBitmap(*args, **kwargs): + """DrawBitmap(self, Bitmap bmp, Double x, Double y, Double w, Double h)""" + return _gdi_.GraphicsContext_DrawBitmap(*args, **kwargs) + + def DrawIcon(*args, **kwargs): + """DrawIcon(self, Icon icon, Double x, Double y, Double w, Double h)""" + 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): + """ + Create(WindowDC dc) -> GraphicsContext + GraphicsContext_Create(Window window) -> GraphicsContext + """ + val = _gdi_.GraphicsContext_Create(*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""" + return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs) + +def GraphicsContext_CreateFromNativeWindow(*args, **kwargs): + """GraphicsContext_CreateFromNativeWindow(void window) -> GraphicsContext""" + 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 + __swig_destroy__ = _gdi_.delete_GraphicsRenderer + __del__ = lambda self : None; + def GetDefaultRenderer(*args, **kwargs): + """GetDefaultRenderer() -> GraphicsRenderer""" + return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args, **kwargs) + + GetDefaultRenderer = staticmethod(GetDefaultRenderer) + def CreateContext(*args): + """ + CreateContext(self, WindowDC dc) -> GraphicsContext + CreateContext(self, Window window) -> GraphicsContext + """ + return _gdi_.GraphicsRenderer_CreateContext(*args) + + def CreateContextFromNativeContext(*args, **kwargs): + """CreateContextFromNativeContext(self, void context) -> GraphicsContext""" + return _gdi_.GraphicsRenderer_CreateContextFromNativeContext(*args, **kwargs) + + def CreateContextFromNativeWindow(*args, **kwargs): + """CreateContextFromNativeWindow(self, void window) -> GraphicsContext""" + return _gdi_.GraphicsRenderer_CreateContextFromNativeWindow(*args, **kwargs) + + def CreatePath(*args, **kwargs): + """CreatePath(self) -> GraphicsPath""" + return _gdi_.GraphicsRenderer_CreatePath(*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 + """ + return _gdi_.GraphicsRenderer_CreateMatrix(*args, **kwargs) + + 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): + """__init__(self, WindowDC dc) -> GCDC""" + _gdi_.GCDC_swiginit(self,_gdi_.new_GCDC(*args, **kwargs)) + self.__dc = args[0] # save a ref so the other dc will not be deleted before self + + __swig_destroy__ = _gdi_.delete_GCDC + __del__ = lambda self : None; + def GetGraphicsContext(*args, **kwargs): + """GetGraphicsContext(self) -> GraphicsContext""" + return _gdi_.GCDC_GetGraphicsContext(*args, **kwargs) + + 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) -> 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) + +#--------------------------------------------------------------------------- + IMAGELIST_DRAW_NORMAL = _gdi_.IMAGELIST_DRAW_NORMAL IMAGELIST_DRAW_TRANSPARENT = _gdi_.IMAGELIST_DRAW_TRANSPARENT IMAGELIST_DRAW_SELECTED = _gdi_.IMAGELIST_DRAW_SELECTED @@ -5010,7 +6045,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 @@ -5220,9 +6254,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 @@ -5268,6 +6304,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 @@ -5304,11 +6365,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 @@ -5326,13 +6388,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) @@ -5483,6 +6565,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): @@ -5616,6 +6700,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) @@ -6262,6 +7383,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)