"""
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)
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))
"""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)
#---------------------------------------------------------------------------
"""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)
"""GetDashCount(self) -> int"""
return _gdi_.Pen_GetDashCount(*args, **kwargs)
+ DashCount = property(GetDashCount,doc="See `GetDashCount`")
def __eq__(*args, **kwargs):
"""__eq__(self, Pen other) -> bool"""
return _gdi_.Pen___eq__(*args, **kwargs)
"""__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)
#---------------------------------------------------------------------------
"""
return _gdi_.Brush_IsHatch(*args, **kwargs)
- def Ok(*args, **kwargs):
+ def IsOk(*args, **kwargs):
"""
- Ok(self) -> bool
+ IsOk(self) -> bool
Returns True if the brush is initialised and valid.
"""
- return _gdi_.Brush_Ok(*args, **kwargs)
+ return _gdi_.Brush_IsOk(*args, **kwargs)
- def __nonzero__(self): return self.Ok()
+ Ok = IsOk
+ def __nonzero__(self): return self.IsOk()
Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`")
Stipple = property(GetStipple,SetStipple,doc="See `GetStipple` and `SetStipple`")
Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`")
_gdi_.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
"""
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)
"""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):
"""LoadFile(self, String name, int type) -> bool"""
return _gdi_.Icon_LoadFile(*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)
"""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`")
"""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)
_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):
"""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)
"""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):
"""__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)
#---------------------------------------------------------------------------
_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)
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):
#---------------------------------------------------------------------------
-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
"""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)
"""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)
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;
# 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
"""
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)
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.
"""
"""
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
"""
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)
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`.
-
+ 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)
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
-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
#---------------------------------------------------------------------------
-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
#---------------------------------------------------------------------------
-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):
+_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))
+_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))
+_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=True)
+ AddArc(self, Point2D c, Double r, Double startAngle, Double endAngle,
+ bool clockwise=True)
+
+ 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)
+
+ def Clip(*args, **kwargs):
+ """
+ Clip(self, Double x, Double y, Double w, Double h)
+
+ Clips drawings to the rectangle.
"""
- GetResolution() -> int
+ return _gdi_.GraphicsContext_Clip(*args, **kwargs)
- Return resolution used in PostScript output.
+ def ResetClip(*args, **kwargs):
"""
- return _gdi_.PostScriptDC_GetResolution(*args, **kwargs)
+ ResetClip(self)
- GetResolution = staticmethod(GetResolution)
-_gdi_.PostScriptDC_swigregister(PostScriptDC)
+ Resets the clipping to original shape.
+ """
+ return _gdi_.GraphicsContext_ResetClip(*args, **kwargs)
-def PostScriptDC_SetResolution(*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))
-_gdi_.MetaFile_swigregister(MetaFile)
+ __swig_destroy__ = _gdi_.delete_GraphicsRenderer
+ __del__ = lambda self : None;
+ def GetDefaultRenderer(*args, **kwargs):
+ """GetDefaultRenderer() -> GraphicsRenderer"""
+ return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args, **kwargs)
-class MetaFileDC(DC):
- """Proxy of C++ MetaFileDC class"""
+ GetDefaultRenderer = staticmethod(GetDefaultRenderer)
+ def CreateContext(*args):
+ """
+ CreateContext(self, WindowDC dc) -> GraphicsContext
+ CreateContext(self, Window window) -> GraphicsContext
+ """
+ return _gdi_.GraphicsRenderer_CreateContext(*args)
+
+ def CreateMeasuringContext(*args, **kwargs):
+ """CreateMeasuringContext(self) -> GraphicsContext"""
+ return _gdi_.GraphicsRenderer_CreateMeasuringContext(*args, **kwargs)
+
+ 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):
+ 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))
-_gdi_.MetaFileDC_swigregister(MetaFileDC)
+ _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
-class PrinterDC(DC):
- """Proxy of C++ PrinterDC class"""
+ __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, 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)
#---------------------------------------------------------------------------
__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
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
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
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
__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) -> 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) -> int
+
+ 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)
"""
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):
"""
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, Colour 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)
"""
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)
projects / wxWidgets.git / blobdiff