]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/src/msw/_gdi.py
removed 'unsigned' from 'unsigned int' so epydoc doesn't get ocnfused
[wxWidgets.git] / wxPython / src / msw / _gdi.py
index 2ea7487ffdc904e758e317cd199d89d5a9797027..d46b6526a17bf15c8e6dad382a3068c9ac650133 100644 (file)
@@ -693,6 +693,24 @@ class Bitmap(GDIObject):
         """CopyFromCursor(self, Cursor cursor) -> bool"""
         return _gdi_.Bitmap_CopyFromCursor(*args, **kwargs)
 
         """CopyFromCursor(self, Cursor cursor) -> bool"""
         return _gdi_.Bitmap_CopyFromCursor(*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"""
     def __nonzero__(self): return self.IsOk() 
     def __eq__(*args, **kwargs):
         """__eq__(self, Bitmap other) -> bool"""
@@ -2388,12 +2406,12 @@ class FontEnumerator(object):
     def __init__(self, *args, **kwargs): 
         """__init__(self) -> FontEnumerator"""
         _gdi_.FontEnumerator_swiginit(self,_gdi_.new_FontEnumerator(*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):
 
     __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):
         return _gdi_.FontEnumerator__setCallbackInfo(*args, **kwargs)
 
     def EnumerateFacenames(*args, **kwargs):
@@ -2855,7 +2873,7 @@ class PyLocale(Locale):
     def __init__(self, *args, **kwargs): 
         """__init__(self, int language=-1, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> PyLocale"""
         _gdi_.PyLocale_swiginit(self,_gdi_.new_PyLocale(*args, **kwargs))
     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;
 
     __swig_destroy__ = _gdi_.delete_PyLocale
     __del__ = lambda self : None;
@@ -3456,6 +3474,10 @@ class DC(_core.Object):
         """
         return _gdi_.DC_BlitPointSize(*args, **kwargs)
 
         """
         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)
     def SetClippingRegion(*args, **kwargs):
         """
         SetClippingRegion(self, int x, int y, int width, int height)
@@ -4476,62 +4498,85 @@ _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 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.
-
+    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): 
         """
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
     def __init__(self, *args, **kwargs): 
         """
-        __init__(self, Bitmap bitmap=NullBitmap) -> MemoryDC
+        __init__(self, DC dc, Colour col) -> DCTextColourChanger
 
 
-        Constructs a new memory device context.
-
-        Use the Ok member to test whether the constructor was successful in
-        creating a usable device context. If a bitmap is not given to this
-        constructor then don't forget to select a bitmap into the DC before
-        drawing on it.
+        wx.DCTextColourChanger can be used to temporarily change the DC text
+        colour and restore it automatically when the object goes out of scope
         """
         """
-        _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs))
-    def SelectObject(*args, **kwargs):
+        _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): 
         """
         """
-        SelectObject(self, Bitmap bitmap)
+        __init__(self, DC dc, Pen pen) -> DCPenChanger
 
 
-        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.
+        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)
 
 
-        If the argument is wx.NullBitmap (or some other uninitialised
-        `wx.Bitmap`) the current bitmap is selected out of the device context,
-        and the original bitmap restored, allowing the current bitmap to be
-        destroyed safely.
+class 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): 
         """
         """
-        return _gdi_.MemoryDC_SelectObject(*args, **kwargs)
+        __init__(self, DC dc, Brush brush) -> DCBrushChanger
 
 
-_gdi_.MemoryDC_swigregister(MemoryDC)
+        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)
 
 
-def MemoryDCFromDC(*args, **kwargs):
+class DCClipper(object):
     """
     """
-    MemoryDCFromDC(DC oldDC) -> MemoryDC
-
-    Creates a DC that is compatible with the oldDC.
+    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.
     """
     """
-    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): 
+        """
+        __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)
 
 #---------------------------------------------------------------------------
 
 
 #---------------------------------------------------------------------------
 
@@ -4676,6 +4721,69 @@ _gdi_.PaintDC_swigregister(PaintDC)
 
 #---------------------------------------------------------------------------
 
 
 #---------------------------------------------------------------------------
 
+class MemoryDC(WindowDC):
+    """
+    A memory device context provides a means to draw graphics onto a
+    bitmap. A bitmap must be selected into the new memory DC before it may
+    be used for anything. Typical usage is as follows::
+
+        dc = wx.MemoryDC()
+        dc.SelectObject(bitmap)
+        # draw on the dc using any of the Draw methods
+        dc.SelectObject(wx.NullBitmap)
+        # the bitmap now contains wahtever was drawn upon it
+
+    Note that the memory DC *must* be deleted (or the bitmap selected out
+    of it) before a bitmap can be reselected into another memory DC.
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Bitmap bitmap=NullBitmap) -> MemoryDC
+
+        Constructs a new memory device context.
+
+        Use the Ok member to test whether the constructor was successful in
+        creating a usable device context. If a bitmap is not given to this
+        constructor then don't forget to select a bitmap into the DC before
+        drawing on it.
+        """
+        _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs))
+    def SelectObject(*args, **kwargs):
+        """
+        SelectObject(self, Bitmap bitmap)
+
+        Selects the bitmap into the device context, to use as the memory
+        bitmap. Selecting the bitmap into a memory DC allows you to draw into
+        the DC, and therefore the bitmap, and also to use Blit to copy the
+        bitmap to a window.
+
+        If the argument is wx.NullBitmap (or some other uninitialised
+        `wx.Bitmap`) the current bitmap is selected out of the device context,
+        and the original bitmap restored, allowing the current bitmap to be
+        destroyed safely.
+        """
+        return _gdi_.MemoryDC_SelectObject(*args, **kwargs)
+
+    def SelectObjectAsSource(*args, **kwargs):
+        """SelectObjectAsSource(self, Bitmap bmp)"""
+        return _gdi_.MemoryDC_SelectObjectAsSource(*args, **kwargs)
+
+_gdi_.MemoryDC_swigregister(MemoryDC)
+
+def MemoryDCFromDC(*args, **kwargs):
+    """
+    MemoryDCFromDC(DC oldDC) -> MemoryDC
+
+    Creates a DC that is compatible with the oldDC.
+    """
+    val = _gdi_.new_MemoryDCFromDC(*args, **kwargs)
+    return val
+
+#---------------------------------------------------------------------------
+
 BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
 BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
 class BufferedDC(MemoryDC):
 BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
 BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
 class BufferedDC(MemoryDC):
@@ -4683,16 +4791,26 @@ 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
     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.
+    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.
 
 
-    It can be used in the same way as any other device context.
+    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.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
     use it in your EVT_PAINT handler, you should look at
-    `wx.BufferedPaintDC`.
+    `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
 
     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.
+    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')
 
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -4719,6 +4837,14 @@ class BufferedDC(MemoryDC):
         """
         return _gdi_.BufferedDC_UnMask(*args, **kwargs)
 
         """
         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):
 _gdi_.BufferedDC_swigregister(BufferedDC)
 
 class BufferedPaintDC(BufferedDC):
@@ -4944,44 +5070,285 @@ _gdi_.PrinterDC_swigregister(PrinterDC)
 
 #---------------------------------------------------------------------------
 
 
 #---------------------------------------------------------------------------
 
-class GraphicsPath(object):
+class GraphicsObject(_core.Object):
+    """
+    This class is the superclass of native graphics objects like pens
+    etc. It provides the internal reference counting.  It is not to be
+    instantiated by user code.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, GraphicsRenderer renderer=None) -> GraphicsObject
+
+        This class is the superclass of native graphics objects like pens
+        etc. It provides the internal reference counting.  It is not to be
+        instantiated by user code.
+        """
+        _gdi_.GraphicsObject_swiginit(self,_gdi_.new_GraphicsObject(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsObject
+    __del__ = lambda self : None;
+    def IsNull(*args, **kwargs):
+        """
+        IsNull(self) -> bool
+
+        Is this object valid (false) or still empty (true)?
+        """
+        return _gdi_.GraphicsObject_IsNull(*args, **kwargs)
+
+    def GetRenderer(*args, **kwargs):
+        """
+        GetRenderer(self) -> GraphicsRenderer
+
+        Returns the renderer that was used to create this instance, or
+        ``None`` if it has not been initialized yet.
+        """
+        return _gdi_.GraphicsObject_GetRenderer(*args, **kwargs)
+
+_gdi_.GraphicsObject_swigregister(GraphicsObject)
+
+class GraphicsPen(GraphicsObject):
+    """
+    A wx.GraphicsPen is a native representation of a pen. It is used for
+    stroking a path on a `wx.GraphicsContext`. The contents are specific and
+    private to the respective renderer. The only way to get a valid instance
+    is via a CreatePen call on the graphics context or the renderer
+    instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsPen
+
+        A wx.GraphicsPen is a native representation of a pen. It is used for
+        stroking a path on a `wx.GraphicsContext`. The contents are specific and
+        private to the respective renderer. The only way to get a valid instance
+        is via a CreatePen call on the graphics context or the renderer
+        instance.
+        """
+        _gdi_.GraphicsPen_swiginit(self,_gdi_.new_GraphicsPen(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsPen
+    __del__ = lambda self : None;
+_gdi_.GraphicsPen_swigregister(GraphicsPen)
+
+class GraphicsBrush(GraphicsObject):
+    """
+    A wx.GraphicsBrush is a native representation of a brush. It is used
+    for filling a path on a `wx.GraphicsContext`. The contents are
+    specific and private to the respective renderer. The only way to get a
+    valid instance is via a Create...Brush call on the graphics context or
+    the renderer instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsBrush
+
+        A wx.GraphicsBrush is a native representation of a brush. It is used
+        for filling a path on a `wx.GraphicsContext`. The contents are
+        specific and private to the respective renderer. The only way to get a
+        valid instance is via a Create...Brush call on the graphics context or
+        the renderer instance.
+        """
+        _gdi_.GraphicsBrush_swiginit(self,_gdi_.new_GraphicsBrush(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsBrush
+    __del__ = lambda self : None;
+_gdi_.GraphicsBrush_swigregister(GraphicsBrush)
+
+class GraphicsFont(GraphicsObject):
+    """
+    A `wx.GraphicsFont` is a native representation of a font (including
+    text colour). The contents are specific an private to the respective
+    renderer.  The only way to get a valid instance is via a CreateFont
+    call on the graphics context or the renderer instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsFont
+
+        A `wx.GraphicsFont` is a native representation of a font (including
+        text colour). The contents are specific an private to the respective
+        renderer.  The only way to get a valid instance is via a CreateFont
+        call on the graphics context or the renderer instance.
+        """
+        _gdi_.GraphicsFont_swiginit(self,_gdi_.new_GraphicsFont(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsFont
+    __del__ = lambda self : None;
+_gdi_.GraphicsFont_swigregister(GraphicsFont)
+
+class GraphicsMatrix(GraphicsObject):
+    """
+    A wx.GraphicsMatrix is a native representation of an affine
+    matrix. The contents are specific an private to the respective
+    renderer. The only way to get a valid instance is via a CreateMatrix
+    call on the graphics context or the renderer instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsMatrix
+
+        A wx.GraphicsMatrix is a native representation of an affine
+        matrix. The contents are specific an private to the respective
+        renderer. The only way to get a valid instance is via a CreateMatrix
+        call on the graphics context or the renderer instance.
+        """
+        _gdi_.GraphicsMatrix_swiginit(self,_gdi_.new_GraphicsMatrix(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsMatrix
+    __del__ = lambda self : None;
+    def Concat(*args, **kwargs):
+        """
+        Concat(self, GraphicsMatrix t)
+
+        Concatenates the passed in matrix to the current matrix.
+        """
+        return _gdi_.GraphicsMatrix_Concat(*args, **kwargs)
+
+    def Set(*args, **kwargs):
+        """
+        Set(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, 
+            Double tx=0.0, Double ty=0.0)
+
+        Sets the matrix to the specified values (default values are the
+        identity matrix.)
+        """
+        return _gdi_.GraphicsMatrix_Set(*args, **kwargs)
+
+    def Invert(*args, **kwargs):
+        """
+        Invert(self)
+
+        Inverts the matrix.
+        """
+        return _gdi_.GraphicsMatrix_Invert(*args, **kwargs)
+
+    def IsEqual(*args, **kwargs):
+        """
+        IsEqual(self, GraphicsMatrix t) -> bool
+
+        Returns ``True`` if the elements of the transformation matrix are equal
+        """
+        return _gdi_.GraphicsMatrix_IsEqual(*args, **kwargs)
+
+    def IsIdentity(*args, **kwargs):
+        """
+        IsIdentity(self) -> bool
+
+        Returns ``True`` if this is the identity matrix
+        """
+        return _gdi_.GraphicsMatrix_IsIdentity(*args, **kwargs)
+
+    def Translate(*args, **kwargs):
+        """
+        Translate(self, Double dx, Double dy)
+
+        Add a translation to this matrix.
+        """
+        return _gdi_.GraphicsMatrix_Translate(*args, **kwargs)
+
+    def Scale(*args, **kwargs):
+        """
+        Scale(self, Double xScale, Double yScale)
+
+        Scales this matrix.
+        """
+        return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)
+
+    def Rotate(*args, **kwargs):
+        """
+        Rotate(self, Double angle)
+
+        Rotates this matrix.  The angle should be specified in radians.
+        """
+        return _gdi_.GraphicsMatrix_Rotate(*args, **kwargs)
+
+    def TransformPoint(*args, **kwargs):
+        """
+        TransformPoint(self, x, y) --> (x, y)
+
+        Applies this matrix to a point, returns the resulting point values
+        """
+        return _gdi_.GraphicsMatrix_TransformPoint(*args, **kwargs)
+
+    def TransformDistance(*args, **kwargs):
+        """
+        TransformDistance(self, dx, dy) --> (dx, dy)
+
+        Applies this matrix to a distance (ie. performs all transforms except
+        translations)
+        """
+        return _gdi_.GraphicsMatrix_TransformDistance(*args, **kwargs)
+
+    def GetNativeMatrix(*args, **kwargs):
+        """
+        GetNativeMatrix(self) -> void
+
+        Returns the native representation of the matrix. For CoreGraphics this
+        is a CFAffineMatrix pointer. For GDIPlus a Matrix Pointer and for
+        Cairo a cairo_matrix_t pointer.  NOTE: For wxPython we still need a
+        way to make this value usable.
+        """
+        return _gdi_.GraphicsMatrix_GetNativeMatrix(*args, **kwargs)
+
+_gdi_.GraphicsMatrix_swigregister(GraphicsMatrix)
+
+class GraphicsPath(GraphicsObject):
     """Proxy of C++ GraphicsPath class"""
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     """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
     __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;
     __swig_destroy__ = _gdi_.delete_GraphicsPath
     __del__ = lambda self : None;
-    def MoveToPoint(*args, **kwargs):
+    def MoveToPoint(*args):
         """
         MoveToPoint(self, Double x, Double y)
         """
         MoveToPoint(self, Double x, Double y)
+        MoveToPoint(self, Point2D p)
 
 
-        Begins a new subpath at (x,y)
+        Begins a new subpath at the specified point.
         """
         """
-        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, Double x, Double y)
+        AddLineToPoint(self, Point2D p)
 
 
-        Adds a straight line from the current point to (x,y) 
+        Adds a straight line from the current point to the specified point.
         """
         """
-        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, 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
         """
 
         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):
         """
         CloseSubpath(self)
 
 
     def CloseSubpath(*args, **kwargs):
         """
         CloseSubpath(self)
 
-        closes the current sub-path
+        Closes the current sub-path.
         """
         return _gdi_.GraphicsPath_CloseSubpath(*args, **kwargs)
 
         """
         return _gdi_.GraphicsPath_CloseSubpath(*args, **kwargs)
 
@@ -4993,15 +5360,17 @@ class GraphicsPath(object):
         """
         return _gdi_.GraphicsPath_GetCurrentPoint(*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, 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
         """
 
         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):
         """
 
     def AddQuadCurveToPoint(*args, **kwargs):
         """
@@ -5016,7 +5385,7 @@ class GraphicsPath(object):
         """
         AddRectangle(self, Double x, Double y, Double w, Double h)
 
         """
         AddRectangle(self, Double x, Double y, Double w, Double h)
 
-        Appends a rectangle as a new closed subpath
+        Appends a rectangle as a new closed subpath.
         """
         return _gdi_.GraphicsPath_AddRectangle(*args, **kwargs)
 
         """
         return _gdi_.GraphicsPath_AddRectangle(*args, **kwargs)
 
@@ -5024,7 +5393,7 @@ class GraphicsPath(object):
         """
         AddCircle(self, Double x, Double y, Double r)
 
         """
         AddCircle(self, Double x, Double y, Double r)
 
-        Appends a circle as a new closed subpath with the given radius.
+        Appends a circle around (x,y) with radius r as a new closed subpath.
         """
         return _gdi_.GraphicsPath_AddCircle(*args, **kwargs)
 
         """
         return _gdi_.GraphicsPath_AddCircle(*args, **kwargs)
 
@@ -5032,15 +5401,82 @@ class GraphicsPath(object):
         """
         AddArcToPoint(self, Double x1, Double y1, Double x2, Double y2, Double r)
 
         """
         AddArcToPoint(self, Double x1, Double y1, Double x2, Double y2, Double r)
 
-        Draws a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1)
+        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)
 
         to (x2,y2), also a straight line from (current) to (x1,y1)
         """
         return _gdi_.GraphicsPath_AddArcToPoint(*args, **kwargs)
 
+    def AddEllipse(*args, **kwargs):
+        """
+        AddEllipse(self, Double x, Double y, Double w, Double h)
+
+        Appends an ellipse fitting into the passed in rectangle.
+        """
+        return _gdi_.GraphicsPath_AddEllipse(*args, **kwargs)
+
+    def AddRoundedRectangle(*args, **kwargs):
+        """
+        AddRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)
+
+        Appends a rounded rectangle.
+        """
+        return _gdi_.GraphicsPath_AddRoundedRectangle(*args, **kwargs)
+
+    def GetNativePath(*args, **kwargs):
+        """
+        GetNativePath(self) -> void
+
+        Returns the native path (CGPathRef for Core Graphics, Path pointer for
+        GDIPlus and a cairo_path_t pointer for cairo).  NOTE: For wxPython we
+        still need a way to make this value usable.
+        """
+        return _gdi_.GraphicsPath_GetNativePath(*args, **kwargs)
+
+    def UnGetNativePath(*args, **kwargs):
+        """
+        UnGetNativePath(self, void p)
+
+        Gives back the native path returned by GetNativePath() because there
+        might be some deallocations necessary (eg on cairo the native path
+        returned by GetNativePath is newly allocated each time).
+        """
+        return _gdi_.GraphicsPath_UnGetNativePath(*args, **kwargs)
+
+    def Transform(*args, **kwargs):
+        """
+        Transform(self, GraphicsMatrix matrix)
+
+        Transforms each point of this path by the matrix
+        """
+        return _gdi_.GraphicsPath_Transform(*args, **kwargs)
+
+    def GetBox(*args, **kwargs):
+        """
+        GetBox(self) -> wxRect2DDouble
+
+        Gets the bounding box enclosing all points (possibly including control points)
+        """
+        return _gdi_.GraphicsPath_GetBox(*args, **kwargs)
+
+    def Contains(*args):
+        """
+        Contains(self, Double x, Double y, int fillStyle=ODDEVEN_RULE) -> bool
+        Contains(self, wxPoint2DDouble c, int fillStyle=ODDEVEN_RULE) -> bool
+
+        Returns ``True`` if the point is within the path.
+        """
+        return _gdi_.GraphicsPath_Contains(*args)
+
 _gdi_.GraphicsPath_swigregister(GraphicsPath)
 
 _gdi_.GraphicsPath_swigregister(GraphicsPath)
 
-class GraphicsContext(object):
-    """Proxy of C++ GraphicsContext class"""
+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
     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
@@ -5050,169 +5486,519 @@ class GraphicsContext(object):
         """
         Create(WindowDC dc) -> GraphicsContext
         Create(Window window) -> GraphicsContext
         """
         Create(WindowDC dc) -> GraphicsContext
         Create(Window window) -> GraphicsContext
+
+        Creates a wx.GraphicsContext either from a window or a DC.
         """
         """
-        return _gdi_.GraphicsContext_Create(*args)
+        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)
 
     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):
     def CreateFromNative(*args, **kwargs):
-        """CreateFromNative(void context) -> GraphicsContext"""
+        """
+        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)
         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):
     def CreatePath(*args, **kwargs):
-        """CreatePath(self) -> GraphicsPath"""
+        """
+        CreatePath(self) -> GraphicsPath
+
+        Creates a native graphics path which is initially empty.
+        """
         return _gdi_.GraphicsContext_CreatePath(*args, **kwargs)
 
         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):
     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):
         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):
         return _gdi_.GraphicsContext_PopState(*args, **kwargs)
 
     def ClipRegion(*args, **kwargs):
-        """ClipRegion(self, Region region)"""
+        """
+        ClipRegion(self, Region region)
+
+        Clips drawings to the region, combined to current clipping region.
+        """
         return _gdi_.GraphicsContext_ClipRegion(*args, **kwargs)
 
     def Clip(*args, **kwargs):
         return _gdi_.GraphicsContext_ClipRegion(*args, **kwargs)
 
     def Clip(*args, **kwargs):
-        """Clip(self, Double x, Double y, Double w, Double h)"""
+        """
+        Clip(self, Double x, Double y, Double w, Double h)
+
+        Clips drawings to the rectangle.
+        """
         return _gdi_.GraphicsContext_Clip(*args, **kwargs)
 
     def ResetClip(*args, **kwargs):
         return _gdi_.GraphicsContext_Clip(*args, **kwargs)
 
     def ResetClip(*args, **kwargs):
-        """ResetClip(self)"""
+        """
+        ResetClip(self)
+
+        Resets the clipping to original shape.
+        """
         return _gdi_.GraphicsContext_ResetClip(*args, **kwargs)
 
     def GetNativeContext(*args, **kwargs):
         return _gdi_.GraphicsContext_ResetClip(*args, **kwargs)
 
     def GetNativeContext(*args, **kwargs):
-        """GetNativeContext(self) -> void"""
+        """
+        GetNativeContext(self) -> void
+
+        Returns the native context (CGContextRef for Core Graphics, Graphics
+        pointer for GDIPlus and cairo_t pointer for cairo).
+        """
         return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs)
 
     def Translate(*args, **kwargs):
         return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs)
 
     def Translate(*args, **kwargs):
-        """Translate(self, Double dx, Double dy)"""
+        """
+        Translate(self, Double dx, Double dy)
+
+        Translates the current transformation matrix.
+        """
         return _gdi_.GraphicsContext_Translate(*args, **kwargs)
 
     def Scale(*args, **kwargs):
         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 of the context.
+        """
         return _gdi_.GraphicsContext_Scale(*args, **kwargs)
 
     def Rotate(*args, **kwargs):
         return _gdi_.GraphicsContext_Scale(*args, **kwargs)
 
     def Rotate(*args, **kwargs):
-        """Rotate(self, Double angle)"""
+        """
+        Rotate(self, Double angle)
+
+        Rotate the current transformation matrix of the context.  ``angle`` is
+        specified in radians.
+        """
         return _gdi_.GraphicsContext_Rotate(*args, **kwargs)
 
         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 the passed in 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 current 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 current transformation 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 SetTextColor(*args, **kwargs):
-        """SetTextColor(self, Colour col)"""
-        return _gdi_.GraphicsContext_SetTextColor(*args, **kwargs)
+    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):
 
     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):
         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):
         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 the path by first filling and then stroking.
+        """
         return _gdi_.GraphicsContext_DrawPath(*args, **kwargs)
 
     def DrawText(*args, **kwargs):
         return _gdi_.GraphicsContext_DrawPath(*args, **kwargs)
 
     def DrawText(*args, **kwargs):
-        """DrawText(self, String str, Double x, Double y)"""
+        """
+        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):
         return _gdi_.GraphicsContext_DrawText(*args, **kwargs)
 
     def DrawRotatedText(*args, **kwargs):
-        """DrawRotatedText(self, String str, Double x, Double y, Double angle)"""
+        """
+        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)
 
         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):
     def GetTextExtent(*args, **kwargs):
-        """GetTextExtend(self, text) --> (width, height, descent, externalLeading)"""
+        """
+        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):
         return _gdi_.GraphicsContext_GetTextExtent(*args, **kwargs)
 
     def GetPartialTextExtents(*args, **kwargs):
-        """GetPartialTextExtents(self, text) -> [widths]"""
+        """
+        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):
         return _gdi_.GraphicsContext_GetPartialTextExtents(*args, **kwargs)
 
     def DrawBitmap(*args, **kwargs):
-        """DrawBitmap(self, Bitmap bmp, Double x, Double y, Double w, Double h)"""
+        """
+        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):
         return _gdi_.GraphicsContext_DrawBitmap(*args, **kwargs)
 
     def DrawIcon(*args, **kwargs):
-        """DrawIcon(self, Icon icon, Double x, Double y, Double w, Double h)"""
+        """
+        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):
         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):
         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):
         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):
         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):
         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):
         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):
         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)
 
         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)
 _gdi_.GraphicsContext_swigregister(GraphicsContext)
+cvar = _gdi_.cvar
+NullGraphicsPen = cvar.NullGraphicsPen
+NullGraphicsBrush = cvar.NullGraphicsBrush
+NullGraphicsFont = cvar.NullGraphicsFont
+NullGraphicsMatrix = cvar.NullGraphicsMatrix
+NullGraphicsPath = cvar.NullGraphicsPath
 
 def GraphicsContext_Create(*args):
   """
     Create(WindowDC dc) -> GraphicsContext
     GraphicsContext_Create(Window window) -> GraphicsContext
 
 def GraphicsContext_Create(*args):
   """
     Create(WindowDC dc) -> GraphicsContext
     GraphicsContext_Create(Window window) -> GraphicsContext
+
+    Creates a wx.GraphicsContext either from a window or a DC.
     """
     """
-  return _gdi_.GraphicsContext_Create(*args)
+  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_CreateMeasuringContext(*args):
+  """
+    GraphicsContext_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
 
 def GraphicsContext_CreateFromNative(*args, **kwargs):
 
 def GraphicsContext_CreateFromNative(*args, **kwargs):
-  """GraphicsContext_CreateFromNative(void context) -> GraphicsContext"""
+  """
+    GraphicsContext_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)
 
   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
+    __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 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
 class GCDC(DC):
     """Proxy of C++ GCDC class"""
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """__init__(self, WindowDC dc) -> GCDC"""
-        _gdi_.GCDC_swiginit(self,_gdi_.new_GCDC(*args, **kwargs))
+    def __init__(self, *args): 
+        """
+        __init__(self, WindowDC dc) -> GCDC
+        __init__(self, Window window) -> GCDC
+        """
+        _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
 
     __swig_destroy__ = _gdi_.delete_GCDC
         self.__dc = args[0] # save a ref so the other dc will not be deleted before self
 
     __swig_destroy__ = _gdi_.delete_GCDC
@@ -5537,7 +6323,6 @@ class GDIObjListBase(object):
     __swig_destroy__ = _gdi_.delete_GDIObjListBase
     __del__ = lambda self : None;
 _gdi_.GDIObjListBase_swigregister(GDIObjListBase)
     __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
 NullBitmap = cvar.NullBitmap
 NullIcon = cvar.NullIcon
 NullCursor = cvar.NullCursor