"""
return _gdi_.Bitmap_SetSize(*args, **kwargs)
+ 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_.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)
#---------------------------------------------------------------------------
+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
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
__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):
"""
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):
#---------------------------------------------------------------------------
-BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-class BufferedDC(DC):
- """
- This simple class provides a simple way to avoid flicker: when drawing
- on it, everything is in fact first drawn on an in-memory buffer (a
- `wx.Bitmap`) and then copied to the screen only once, when this object
- is destroyed.
-
- It can be used in the same way as any other device context.
- wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
- use it in your EVT_PAINT handler, you should look at
- `wx.BufferedPaintDC`.
-
- Please note that GTK+ 2.0 and OS X provide double buffering themselves
- natively. wxBufferedDC is aware of this however, and will bypass the buffering
- unless an explicit buffer bitmap is given.
-
- """
- thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
- __repr__ = _swig_repr
- def __init__(self, *args):
- """
- __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
- __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
- __init__(self, Window win, 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
#---------------------------------------------------------------------------
-if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
- _AutoBufferedPaintDCBase = PaintDC
-else:
- _AutoBufferedPaintDCBase = BufferedPaintDC
-
-class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
+BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
+BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
+class BufferedDC(MemoryDC):
+ """
+ This simple class provides a simple way to avoid flicker: when drawing
+ on it, everything is in fact first drawn on an in-memory buffer (a
+ `wx.Bitmap`) and then copied to the screen only once, when this object
+ is destroyed. You can either provide a buffer bitmap yourself, and
+ reuse it the next time something needs painted, or you can let the
+ buffered DC create and provide a buffer bitmap itself.
+
+ Buffered DCs can be used in the same way as any other device context.
+ wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
+ use it in your EVT_PAINT handler, you should look at
+ `wx.BufferedPaintDC`. You can also use a wx.BufferedDC without
+ providing a target DC. In this case the operations done on the dc
+ will only be written to the buffer bitmap and *not* to any window, so
+ you will want to have provided the buffer bitmap and then reuse it
+ when it needs painted to the window.
+
+ Please note that GTK+ 2.0 and OS X provide double buffering themselves
+ natively. You may want to use `wx.Window.IsDoubleBuffered` to
+ determine whether you need to use buffering or not, or use
+ `wx.AutoBufferedPaintDC` to avoid needless double buffering on systems
+ that already do it automatically.
+
+
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args):
+ """
+ __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+ __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+
+ Constructs a buffered DC.
+ """
+ _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
+ self.__dc = args[0] # save a ref so the other dc will not be deleted before self
+
+ __swig_destroy__ = _gdi_.delete_BufferedDC
+ __del__ = lambda self : None;
+ def UnMask(*args, **kwargs):
+ """
+ UnMask(self)
+
+ Blits the buffer to the dc, and detaches the dc from the buffer (so it
+ can be effectively used once only). This is usually only called in
+ the destructor.
+ """
+ return _gdi_.BufferedDC_UnMask(*args, **kwargs)
+
+ def SetStyle(*args, **kwargs):
+ """SetStyle(self, int style)"""
+ return _gdi_.BufferedDC_SetStyle(*args, **kwargs)
+
+ def GetStyle(*args, **kwargs):
+ """GetStyle(self) -> int"""
+ return _gdi_.BufferedDC_GetStyle(*args, **kwargs)
+
+_gdi_.BufferedDC_swigregister(BufferedDC)
+
+class BufferedPaintDC(BufferedDC):
+ """
+ This is a subclass of `wx.BufferedDC` which can be used inside of an
+ EVT_PAINT event handler. Just create an object of this class instead
+ of `wx.PaintDC` and that's all you have to do to (mostly) avoid
+ flicker. The only thing to watch out for is that if you are using this
+ class together with `wx.ScrolledWindow`, you probably do **not** want
+ to call `wx.Window.PrepareDC` on it as it already does this internally
+ for the real underlying `wx.PaintDC`.
+
+ If your window is already fully buffered in a `wx.Bitmap` then your
+ EVT_PAINT handler can be as simple as just creating a
+ ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
+ automatically when it is destroyed. For example::
+
+ def OnPaint(self, event):
+ dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
+
+ Create a buffered paint DC. As with `wx.BufferedDC`, you may either
+ provide the bitmap to be used for buffering or let this object create
+ one internally (in the latter case, the size of the client part of the
+ window is automatically used).
+ """
+ _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
+_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
+
+#---------------------------------------------------------------------------
+
+class AutoBufferedPaintDC(DC):
"""
If the current platform double buffers by default then this DC is the
same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
+
+ :see: `wx.AutoBufferedPaintDCFactory`
+
"""
- def __init__(self, window):
- _AutoBufferedPaintDCBase.__init__(self, window)
+ 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):
#---------------------------------------------------------------------------
-class GraphicsPath(object):
+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')
- def __init__(self): raise AttributeError, "No constructor defined"
__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, **kwargs):
+ 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, **kwargs)
+ return _gdi_.GraphicsPath_MoveToPoint(*args)
- def AddLineToPoint(*args, **kwargs):
+ 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, **kwargs)
+ return _gdi_.GraphicsPath_AddLineToPoint(*args)
- def AddCurveToPoint(*args, **kwargs):
+ 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, **kwargs)
+ 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):
"""
"""
return _gdi_.GraphicsPath_GetCurrentPoint(*args, **kwargs)
- def AddArc(*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, **kwargs)
+ return _gdi_.GraphicsPath_AddArc(*args)
def AddQuadCurveToPoint(*args, **kwargs):
"""
"""
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(object):
+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, **kwargs):
- """Create(WindowDC dc) -> GraphicsContext"""
- val = _gdi_.GraphicsContext_Create(*args, **kwargs)
- val.__dc = args[0] # save a ref so the other dc will not be deleted before self
+ 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"""
+ """
+ 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)"""
+ """
+ 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)"""
+ """
+ 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, Region region)"""
+ """
+ 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(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(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(self, Double angle)
+
+ rotate (radians) the current transformation matrix CTM of the context
+ """
return _gdi_.GraphicsContext_Rotate(*args, **kwargs)
- def SetPen(*args, **kwargs):
- """SetPen(self, Pen pen)"""
- return _gdi_.GraphicsContext_SetPen(*args, **kwargs)
+ def ConcatTransform(*args, **kwargs):
+ """
+ ConcatTransform(self, GraphicsMatrix matrix)
- def SetBrush(*args, **kwargs):
- """SetBrush(self, Brush brush)"""
- return _gdi_.GraphicsContext_SetBrush(*args, **kwargs)
+ concatenates this transform with the current transform of this context
+ """
+ return _gdi_.GraphicsContext_ConcatTransform(*args, **kwargs)
- def SetLinearGradientBrush(*args, **kwargs):
+ def SetTransform(*args, **kwargs):
"""
- SetLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1,
- Colour c2)
+ SetTransform(self, GraphicsMatrix matrix)
+
+ sets the transform of this context
"""
- return _gdi_.GraphicsContext_SetLinearGradientBrush(*args, **kwargs)
+ return _gdi_.GraphicsContext_SetTransform(*args, **kwargs)
- def SetRadialGradientBrush(*args, **kwargs):
+ def GetTransform(*args, **kwargs):
"""
- SetRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius,
- Colour oColor, Colour cColor)
+ GetTransform(self) -> GraphicsMatrix
+
+ gets the matrix of this context
"""
- return _gdi_.GraphicsContext_SetRadialGradientBrush(*args, **kwargs)
+ return _gdi_.GraphicsContext_GetTransform(*args, **kwargs)
- def SetFont(*args, **kwargs):
- """SetFont(self, Font font)"""
- return _gdi_.GraphicsContext_SetFont(*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)
- def SetTextColor(*args, **kwargs):
- """SetTextColor(self, Colour col)"""
- return _gdi_.GraphicsContext_SetTextColor(*args, **kwargs)
+ sets the font
+ """
+ return _gdi_.GraphicsContext_SetFont(*args)
def StrokePath(*args, **kwargs):
- """StrokePath(self, GraphicsPath path)"""
+ """
+ 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=WINDING_RULE)"""
+ """
+ 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=WINDING_RULE)"""
+ """
+ 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):
"""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):
- """GetTextExtend(self, text) --> (width, height, descent, externalLeading)"""
+ """GetTextExtent(self, text) --> (width, height)"""
return _gdi_.GraphicsContext_GetTextExtent(*args, **kwargs)
def GetPartialTextExtents(*args, **kwargs):
return _gdi_.GraphicsContext_DrawIcon(*args, **kwargs)
def StrokeLine(*args, **kwargs):
- """StrokeLine(self, Double x1, Double y1, Double x2, Double y2)"""
+ """
+ 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)"""
+ """
+ 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)"""
+ """
+ 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=WINDING_RULE)"""
+ """
+ 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)"""
+ """
+ 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)"""
+ """
+ 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)"""
+ """
+ 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, **kwargs):
- """GraphicsContext_Create(WindowDC dc) -> GraphicsContext"""
- val = _gdi_.GraphicsContext_Create(*args, **kwargs)
- val.__dc = args[0] # save a ref so the other dc will not be deleted before self
+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')
__swig_destroy__ = _gdi_.delete_GCDC
__del__ = lambda self : None;
- def GetGraphicContext(*args, **kwargs):
- """GetGraphicContext(self) -> GraphicsContext"""
- return _gdi_.GCDC_GetGraphicContext(*args, **kwargs)
+ 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):
__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
projects / wxWidgets.git / blobdiff