X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/72ef6efb1f1819e0b1187cedfd8989d4a37bf457..474e2ff2c8901e5ef5b376d3206d95dbaab62625:/wxPython/src/msw/_gdi.py

diff --git a/wxPython/src/msw/_gdi.py b/wxPython/src/msw/_gdi.py
index 0b131b361a..a9b9745df1 100644
--- a/wxPython/src/msw/_gdi.py
+++ b/wxPython/src/msw/_gdi.py
@@ -146,15 +146,16 @@ class Colour(_core.Object):
         """
         return _gdi_.Colour_Alpha(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
+    def IsOk(*args, **kwargs):
         """
-        Ok(self) -> bool
+        IsOk(self) -> bool
 
         Returns True if the colour object is valid (the colour has been
         initialised with RGB values).
         """
-        return _gdi_.Colour_Ok(*args, **kwargs)
+        return _gdi_.Colour_IsOk(*args, **kwargs)
 
+    Ok = IsOk 
     def Set(*args, **kwargs):
         """
         Set(self, byte red, byte green, byte blue, byte alpha=ALPHA_OPAQUE)
@@ -239,7 +240,9 @@ class Colour(_core.Object):
     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
     def __str__(self):                  return str(self.Get(True))
     def __repr__(self):                 return 'wx.Colour' + str(self.Get(True))
-    def __nonzero__(self):              return self.Ok()
+    def __len__(self):                  return len(self.Get())
+    def __getitem__(self, index):       return self.Get()[index]
+    def __nonzero__(self):              return self.IsOk()
     __safe_for_unpickling__ = True
     def __reduce__(self):               return (Colour, self.Get(True))
 
@@ -291,11 +294,12 @@ class Palette(GDIObject):
         """GetColoursCount(self) -> int"""
         return _gdi_.Palette_GetColoursCount(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
-        """Ok(self) -> bool"""
-        return _gdi_.Palette_Ok(*args, **kwargs)
+    def IsOk(*args, **kwargs):
+        """IsOk(self) -> bool"""
+        return _gdi_.Palette_IsOk(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    Ok = IsOk 
+    def __nonzero__(self): return self.IsOk() 
     ColoursCount = property(GetColoursCount,doc="See `GetColoursCount`") 
 _gdi_.Palette_swigregister(Palette)
 
@@ -330,10 +334,11 @@ class Pen(GDIObject):
         """GetWidth(self) -> int"""
         return _gdi_.Pen_GetWidth(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
-        """Ok(self) -> bool"""
-        return _gdi_.Pen_Ok(*args, **kwargs)
+    def IsOk(*args, **kwargs):
+        """IsOk(self) -> bool"""
+        return _gdi_.Pen_IsOk(*args, **kwargs)
 
+    Ok = IsOk 
     def SetCap(*args, **kwargs):
         """SetCap(self, int cap_style)"""
         return _gdi_.Pen_SetCap(*args, **kwargs)
@@ -394,7 +399,7 @@ class Pen(GDIObject):
         """__ne__(self, Pen other) -> bool"""
         return _gdi_.Pen___ne__(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    def __nonzero__(self): return self.IsOk() 
     Cap = property(GetCap,SetCap,doc="See `GetCap` and `SetCap`") 
     Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`") 
     Dashes = property(GetDashes,SetDashes,doc="See `GetDashes` and `SetDashes`") 
@@ -481,15 +486,16 @@ class Brush(GDIObject):
         """
         return _gdi_.Brush_IsHatch(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
+    def IsOk(*args, **kwargs):
         """
-        Ok(self) -> bool
+        IsOk(self) -> bool
 
         Returns True if the brush is initialised and valid.
         """
-        return _gdi_.Brush_Ok(*args, **kwargs)
+        return _gdi_.Brush_IsOk(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    Ok = IsOk 
+    def __nonzero__(self): return self.IsOk() 
     Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`") 
     Stipple = property(GetStipple,SetStipple,doc="See `GetStipple` and `SetStipple`") 
     Style = property(GetStyle,SetStyle,doc="See `GetStyle` and `SetStyle`") 
@@ -532,10 +538,11 @@ class Bitmap(GDIObject):
         """SetHandle(self, long handle)"""
         return _gdi_.Bitmap_SetHandle(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
-        """Ok(self) -> bool"""
-        return _gdi_.Bitmap_Ok(*args, **kwargs)
+    def IsOk(*args, **kwargs):
+        """IsOk(self) -> bool"""
+        return _gdi_.Bitmap_IsOk(*args, **kwargs)
 
+    Ok = IsOk 
     def GetWidth(*args, **kwargs):
         """
         GetWidth(self) -> int
@@ -686,7 +693,25 @@ class Bitmap(GDIObject):
         """CopyFromCursor(self, Cursor cursor) -> bool"""
         return _gdi_.Bitmap_CopyFromCursor(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    def CopyFromBuffer(*args, **kwargs):
+        """
+        CopyFromBuffer(self, buffer data)
+
+        Copy data from a RGB buffer object to replace the bitmap pixel data.
+        See `wxBitmapFromBuffer` for more .
+        """
+        return _gdi_.Bitmap_CopyFromBuffer(*args, **kwargs)
+
+    def CopyFromBufferRGBA(*args, **kwargs):
+        """
+        CopyFromBufferRGBA(self, buffer data)
+
+        Copy data from a RGBA buffer object to replace the bitmap pixel data.
+        See `wxBitmapFromBufferRGBA` for more .
+        """
+        return _gdi_.Bitmap_CopyFromBufferRGBA(*args, **kwargs)
+
+    def __nonzero__(self): return self.IsOk() 
     def __eq__(*args, **kwargs):
         """__eq__(self, Bitmap other) -> bool"""
         return _gdi_.Bitmap___eq__(*args, **kwargs)
@@ -1136,10 +1161,11 @@ class Icon(GDIObject):
         """SetHandle(self, long handle)"""
         return _gdi_.Icon_SetHandle(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
-        """Ok(self) -> bool"""
-        return _gdi_.Icon_Ok(*args, **kwargs)
+    def IsOk(*args, **kwargs):
+        """IsOk(self) -> bool"""
+        return _gdi_.Icon_IsOk(*args, **kwargs)
 
+    Ok = IsOk 
     def GetWidth(*args, **kwargs):
         """GetWidth(self) -> int"""
         return _gdi_.Icon_GetWidth(*args, **kwargs)
@@ -1172,7 +1198,7 @@ class Icon(GDIObject):
         """CopyFromBitmap(self, Bitmap bmp)"""
         return _gdi_.Icon_CopyFromBitmap(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    def __nonzero__(self): return self.IsOk() 
     Depth = property(GetDepth,SetDepth,doc="See `GetDepth` and `SetDepth`") 
     Height = property(GetHeight,SetHeight,doc="See `GetHeight` and `SetHeight`") 
     Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`") 
@@ -1211,7 +1237,7 @@ class IconLocation(object):
         """IsOk(self) -> bool"""
         return _gdi_.IconLocation_IsOk(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    def __nonzero__(self): return self.IsOk() 
     def SetFileName(*args, **kwargs):
         """SetFileName(self, String filename)"""
         return _gdi_.IconLocation_SetFileName(*args, **kwargs)
@@ -1307,11 +1333,12 @@ class Cursor(GDIObject):
         """
         return _gdi_.Cursor_SetHandle(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
-        """Ok(self) -> bool"""
-        return _gdi_.Cursor_Ok(*args, **kwargs)
+    def IsOk(*args, **kwargs):
+        """IsOk(self) -> bool"""
+        return _gdi_.Cursor_IsOk(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    Ok = IsOk 
+    def __nonzero__(self): return self.IsOk() 
     def GetWidth(*args, **kwargs):
         """GetWidth(self) -> int"""
         return _gdi_.Cursor_GetWidth(*args, **kwargs)
@@ -1980,15 +2007,16 @@ class Font(GDIObject):
         _gdi_.Font_swiginit(self,_gdi_.new_Font(*args, **kwargs))
     __swig_destroy__ = _gdi_.delete_Font
     __del__ = lambda self : None;
-    def Ok(*args, **kwargs):
+    def IsOk(*args, **kwargs):
         """
-        Ok(self) -> bool
+        IsOk(self) -> bool
 
         Returns ``True`` if this font was successfully created.
         """
-        return _gdi_.Font_Ok(*args, **kwargs)
+        return _gdi_.Font_IsOk(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    Ok = IsOk 
+    def __nonzero__(self): return self.IsOk() 
     def __eq__(*args, **kwargs):
         """__eq__(self, Font other) -> bool"""
         return _gdi_.Font___eq__(*args, **kwargs)
@@ -2378,12 +2406,12 @@ class FontEnumerator(object):
     def __init__(self, *args, **kwargs): 
         """__init__(self) -> FontEnumerator"""
         _gdi_.FontEnumerator_swiginit(self,_gdi_.new_FontEnumerator(*args, **kwargs))
-        self._setCallbackInfo(self, FontEnumerator, 0)
+        FontEnumerator._setCallbackInfo(self, self, FontEnumerator)
 
     __swig_destroy__ = _gdi_.delete_FontEnumerator
     __del__ = lambda self : None;
     def _setCallbackInfo(*args, **kwargs):
-        """_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)"""
+        """_setCallbackInfo(self, PyObject self, PyObject _class, int incref=0)"""
         return _gdi_.FontEnumerator__setCallbackInfo(*args, **kwargs)
 
     def EnumerateFacenames(*args, **kwargs):
@@ -2845,7 +2873,7 @@ class PyLocale(Locale):
     def __init__(self, *args, **kwargs): 
         """__init__(self, int language=-1, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> PyLocale"""
         _gdi_.PyLocale_swiginit(self,_gdi_.new_PyLocale(*args, **kwargs))
-        self._setCallbackInfo(self, PyLocale)
+        PyLocale._setCallbackInfo(self, self, PyLocale)
 
     __swig_destroy__ = _gdi_.delete_PyLocale
     __del__ = lambda self : None;
@@ -3446,6 +3474,10 @@ class DC(_core.Object):
         """
         return _gdi_.DC_BlitPointSize(*args, **kwargs)
 
+    def GetAsBitmap(*args, **kwargs):
+        """GetAsBitmap(self, Rect subrect=None) -> Bitmap"""
+        return _gdi_.DC_GetAsBitmap(*args, **kwargs)
+
     def SetClippingRegion(*args, **kwargs):
         """
         SetClippingRegion(self, int x, int y, int width, int height)
@@ -3911,14 +3943,15 @@ class DC(_core.Object):
         """
         return _gdi_.DC_GetPPI(*args, **kwargs)
 
-    def Ok(*args, **kwargs):
+    def IsOk(*args, **kwargs):
         """
-        Ok(self) -> bool
+        IsOk(self) -> bool
 
         Returns true if the DC is ok to use.
         """
-        return _gdi_.DC_Ok(*args, **kwargs)
+        return _gdi_.DC_IsOk(*args, **kwargs)
 
+    Ok = IsOk 
     def GetBackgroundMode(*args, **kwargs):
         """
         GetBackgroundMode(self) -> int
@@ -4221,7 +4254,27 @@ class DC(_core.Object):
         """
         return _gdi_.DC_GetBoundingBox(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    def __nonzero__(self): return self.IsOk() 
+    def GetLayoutDirection(*args, **kwargs):
+        """
+        GetLayoutDirection(self) -> int
+
+        Get the layout direction (LTR or RTL)_ for this dc.  On platforms
+        where RTL layout is supported, the return value will either be
+        ``wx.Layout_LeftToRight`` or ``wx.Layout_RightToLeft``.
+        ``wx.Layout_Default`` is returned if layout direction is not
+        supported.
+        """
+        return _gdi_.DC_GetLayoutDirection(*args, **kwargs)
+
+    def SetLayoutDirection(*args, **kwargs):
+        """
+        SetLayoutDirection(self, int dir)
+
+        Change the layout direction for this dc.
+        """
+        return _gdi_.DC_SetLayoutDirection(*args, **kwargs)
+
     def GetHDC(*args, **kwargs):
         """GetHDC(self) -> long"""
         return _gdi_.DC_GetHDC(*args, **kwargs)
@@ -4440,151 +4493,90 @@ class DC(_core.Object):
     TextExtent = property(GetTextExtent,doc="See `GetTextExtent`") 
     TextForeground = property(GetTextForeground,SetTextForeground,doc="See `GetTextForeground` and `SetTextForeground`") 
     UserScale = property(GetUserScale,SetUserScale,doc="See `GetUserScale` and `SetUserScale`") 
+    LayoutDirection = property(GetLayoutDirection,SetLayoutDirection) 
 _gdi_.DC_swigregister(DC)
 
 #---------------------------------------------------------------------------
 
-class MemoryDC(DC):
+class DCTextColourChanger(object):
     """
-    A memory device context provides a means to draw graphics onto a
-    bitmap. A bitmap must be selected into the new memory DC before it may
-    be used for anything. Typical usage is as follows::
-
-        dc = wx.MemoryDC()
-        dc.SelectObject(bitmap)
-        # draw on the dc usign any of the Draw methods
-        dc.SelectObject(wx.NullBitmap)
-        # the bitmap now contains wahtever was drawn upon it
-
-    Note that the memory DC *must* be deleted (or the bitmap selected out
-    of it) before a bitmap can be reselected into another memory DC.
-
+    wx.DCTextColourChanger can be used to temporarily change the DC text
+    colour and restore it automatically when the object goes out of scope
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
     def __init__(self, *args, **kwargs): 
         """
-        __init__(self) -> MemoryDC
-
-        Constructs a new memory device context.
-
-        Use the Ok member to test whether the constructor was successful in
-        creating a usable device context. Don't forget to select a bitmap into
-        the DC before drawing on it.
-        """
-        _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs))
-    def SelectObject(*args, **kwargs):
-        """
-        SelectObject(self, Bitmap bitmap)
-
-        Selects the bitmap into the device context, to use as the memory
-        bitmap. Selecting the bitmap into a memory DC allows you to draw into
-        the DC, and therefore the bitmap, and also to use Blit to copy the
-        bitmap to a window.
+        __init__(self, DC dc, Colour col) -> DCTextColourChanger
 
-        If the argument is wx.NullBitmap (or some other uninitialised
-        `wx.Bitmap`) the current bitmap is selected out of the device context,
-        and the original bitmap restored, allowing the current bitmap to be
-        destroyed safely.
+        wx.DCTextColourChanger can be used to temporarily change the DC text
+        colour and restore it automatically when the object goes out of scope
         """
-        return _gdi_.MemoryDC_SelectObject(*args, **kwargs)
-
-_gdi_.MemoryDC_swigregister(MemoryDC)
+        _gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_DCTextColourChanger
+    __del__ = lambda self : None;
+_gdi_.DCTextColourChanger_swigregister(DCTextColourChanger)
 
-def MemoryDCFromDC(*args, **kwargs):
+class DCPenChanger(object):
     """
-    MemoryDCFromDC(DC oldDC) -> MemoryDC
-
-    Creates a DC that is compatible with the oldDC.
+    wx.DCPenChanger can be used to temporarily change the DC pen and
+    restore it automatically when the object goes out of scope
     """
-    val = _gdi_.new_MemoryDCFromDC(*args, **kwargs)
-    return val
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, DC dc, Pen pen) -> DCPenChanger
 
-#---------------------------------------------------------------------------
+        wx.DCPenChanger can be used to temporarily change the DC pen and
+        restore it automatically when the object goes out of scope
+        """
+        _gdi_.DCPenChanger_swiginit(self,_gdi_.new_DCPenChanger(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_DCPenChanger
+    __del__ = lambda self : None;
+_gdi_.DCPenChanger_swigregister(DCPenChanger)
 
-BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-class BufferedDC(MemoryDC):
+class DCBrushChanger(object):
     """
-    This simple class provides a simple way to avoid flicker: when drawing
-    on it, everything is in fact first drawn on an in-memory buffer (a
-    `wx.Bitmap`) and then copied to the screen only once, when this object
-    is destroyed.
-
-    It can be used in the same way as any other device context.
-    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
-    use it in your EVT_PAINT handler, you should look at
-    `wx.BufferedPaintDC`.
-
-    Please note that GTK+ 2.0 and OS X provide double buffering themselves
-    natively so using this class on those platforms will normally result
-    in an unneeded level of buffering.
-
+    wx.DCBrushChanger can be used to temporarily change the DC brush and
+    restore it automatically when the object goes out of scope
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
-    def __init__(self, *args): 
+    def __init__(self, *args, **kwargs): 
         """
-        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
-        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+        __init__(self, DC dc, Brush brush) -> DCBrushChanger
 
-        Constructs a buffered DC.
+        wx.DCBrushChanger can be used to temporarily change the DC brush and
+        restore it automatically when the object goes out of scope
         """
-        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
-        self.__dc = args[0] # save a ref so the other dc will not be deleted before self
-
-    __swig_destroy__ = _gdi_.delete_BufferedDC
+        _gdi_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_DCBrushChanger
     __del__ = lambda self : None;
-    def UnMask(*args, **kwargs):
-        """
-        UnMask(self)
-
-        Blits the buffer to the dc, and detaches the dc from the buffer (so it
-        can be effectively used once only).  This is usually only called in
-        the destructor.
-        """
-        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
-
-_gdi_.BufferedDC_swigregister(BufferedDC)
+_gdi_.DCBrushChanger_swigregister(DCBrushChanger)
 
-class BufferedPaintDC(BufferedDC):
+class DCClipper(object):
     """
-    This is a subclass of `wx.BufferedDC` which can be used inside of an
-    EVT_PAINT event handler. Just create an object of this class instead
-    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
-    flicker. The only thing to watch out for is that if you are using this
-    class together with `wx.ScrolledWindow`, you probably do **not** want
-    to call `wx.Window.PrepareDC` on it as it already does this internally
-    for the real underlying `wx.PaintDC`.
-
-    If your window is already fully buffered in a `wx.Bitmap` then your
-    EVT_PAINT handler can be as simple as just creating a
-    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
-    automatically when it is destroyed.  For example::
-
-        def OnPaint(self, event):
-            dc = wx.BufferedPaintDC(self, self.buffer)
-
-
-
-
-
+    wx.wxDCClipper sets the DC's clipping region when it is constructed,
+    and then automatically destroys the clipping region when the clipper
+    goes out of scope.
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
+    def __init__(self, *args): 
         """
-        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
-
-        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
-        provide the bitmap to be used for buffering or let this object create
-        one internally (in the latter case, the size of the client part of the
-        window is automatically used).
-
+        __init__(self, DC dc, Region r) -> DCClipper
+        __init__(self, DC dc, Rect r) -> DCClipper
+        __init__(self, DC dc, int x, int y, int w, int h) -> DCClipper
 
+        wx.wxDCClipper sets the DC's clipping region when it is constructed,
+        and then automatically destroys the clipping region when the clipper
+        goes out of scope.
         """
-        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
-_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
+        _gdi_.DCClipper_swiginit(self,_gdi_.new_DCClipper(*args))
+    __swig_destroy__ = _gdi_.delete_DCClipper
+    __del__ = lambda self : None;
+_gdi_.DCClipper_swigregister(DCClipper)
 
 #---------------------------------------------------------------------------
 
@@ -4729,107 +4721,314 @@ _gdi_.PaintDC_swigregister(PaintDC)
 
 #---------------------------------------------------------------------------
 
-class MirrorDC(DC):
-    """
-    wx.MirrorDC is a simple wrapper class which is always associated with a
-    real `wx.DC` object and either forwards all of its operations to it
-    without changes (no mirroring takes place) or exchanges x and y
-    coordinates which makes it possible to reuse the same code to draw a
-    figure and its mirror -- i.e. reflection related to the diagonal line
-    x == y.
+class MemoryDC(WindowDC):
     """
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """
-        __init__(self, DC dc, bool mirror) -> MirrorDC
+    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::
 
-        Creates a mirrored DC associated with the real *dc*.  Everything drawn
-        on the wx.MirrorDC will appear on the *dc*, and will be mirrored if
-        *mirror* is True.
-        """
-        _gdi_.MirrorDC_swiginit(self,_gdi_.new_MirrorDC(*args, **kwargs))
-_gdi_.MirrorDC_swigregister(MirrorDC)
+        dc = wx.MemoryDC()
+        dc.SelectObject(bitmap)
+        # draw on the dc using any of the Draw methods
+        dc.SelectObject(wx.NullBitmap)
+        # the bitmap now contains wahtever was drawn upon it
 
-#---------------------------------------------------------------------------
+    Note that the memory DC *must* be deleted (or the bitmap selected out
+    of it) before a bitmap can be reselected into another memory DC.
 
-class PostScriptDC(DC):
-    """This is a `wx.DC` that can write to PostScript files on any platform."""
+    """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
     def __init__(self, *args, **kwargs): 
         """
-        __init__(self, wxPrintData printData) -> PostScriptDC
-
-        Constructs a PostScript printer device context from a `wx.PrintData`
-        object.
-        """
-        _gdi_.PostScriptDC_swiginit(self,_gdi_.new_PostScriptDC(*args, **kwargs))
-    def GetPrintData(*args, **kwargs):
-        """GetPrintData(self) -> wxPrintData"""
-        return _gdi_.PostScriptDC_GetPrintData(*args, **kwargs)
+        __init__(self, Bitmap bitmap=NullBitmap) -> MemoryDC
 
-    def SetPrintData(*args, **kwargs):
-        """SetPrintData(self, wxPrintData data)"""
-        return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs)
+        Constructs a new memory device context.
 
-    def SetResolution(*args, **kwargs):
+        Use the Ok member to test whether the constructor was successful in
+        creating a usable device context. If a bitmap is not given to this
+        constructor then don't forget to select a bitmap into the DC before
+        drawing on it.
         """
-        SetResolution(int ppi)
-
-        Set resolution (in pixels per inch) that will be used in PostScript
-        output. Default is 720ppi.
+        _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs))
+    def SelectObject(*args, **kwargs):
         """
-        return _gdi_.PostScriptDC_SetResolution(*args, **kwargs)
+        SelectObject(self, Bitmap bitmap)
 
-    SetResolution = staticmethod(SetResolution)
-    def GetResolution(*args, **kwargs):
-        """
-        GetResolution() -> int
+        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.
 
-        Return resolution used in PostScript output.
+        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_.PostScriptDC_GetResolution(*args, **kwargs)
+        return _gdi_.MemoryDC_SelectObject(*args, **kwargs)
 
-    GetResolution = staticmethod(GetResolution)
-    PrintData = property(GetPrintData,SetPrintData,doc="See `GetPrintData` and `SetPrintData`") 
-_gdi_.PostScriptDC_swigregister(PostScriptDC)
+    def SelectObjectAsSource(*args, **kwargs):
+        """SelectObjectAsSource(self, Bitmap bmp)"""
+        return _gdi_.MemoryDC_SelectObjectAsSource(*args, **kwargs)
 
-def PostScriptDC_SetResolution(*args, **kwargs):
-  """
-    PostScriptDC_SetResolution(int ppi)
+_gdi_.MemoryDC_swigregister(MemoryDC)
 
-    Set resolution (in pixels per inch) that will be used in PostScript
-    output. Default is 720ppi.
+def MemoryDCFromDC(*args, **kwargs):
     """
-  return _gdi_.PostScriptDC_SetResolution(*args, **kwargs)
-
-def PostScriptDC_GetResolution(*args):
-  """
-    PostScriptDC_GetResolution() -> int
+    MemoryDCFromDC(DC oldDC) -> MemoryDC
 
-    Return resolution used in PostScript output.
+    Creates a DC that is compatible with the oldDC.
     """
-  return _gdi_.PostScriptDC_GetResolution(*args)
+    val = _gdi_.new_MemoryDCFromDC(*args, **kwargs)
+    return val
 
 #---------------------------------------------------------------------------
 
-class MetaFile(_core.Object):
-    """Proxy of C++ MetaFile class"""
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """__init__(self, String filename=EmptyString) -> MetaFile"""
-        _gdi_.MetaFile_swiginit(self,_gdi_.new_MetaFile(*args, **kwargs))
-    __swig_destroy__ = _gdi_.delete_MetaFile
-    __del__ = lambda self : None;
-    def Ok(*args, **kwargs):
-        """Ok(self) -> bool"""
-        return _gdi_.MetaFile_Ok(*args, **kwargs)
-
-    def SetClipboard(*args, **kwargs):
-        """SetClipboard(self, int width=0, int height=0) -> bool"""
-        return _gdi_.MetaFile_SetClipboard(*args, **kwargs)
+BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
+BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
+class BufferedDC(MemoryDC):
+    """
+    This simple class provides a simple way to avoid flicker: when drawing
+    on it, everything is in fact first drawn on an in-memory buffer (a
+    `wx.Bitmap`) and then copied to the screen only once, when this object
+    is destroyed.  You can either provide a buffer bitmap yourself, and
+    reuse it the next time something needs painted, or you can let the
+    buffered DC create and provide a buffer bitmap itself.
+
+    Buffered DCs can be used in the same way as any other device context.
+    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
+    use it in your EVT_PAINT handler, you should look at
+    `wx.BufferedPaintDC`.  You can also use a wx.BufferedDC without
+    providing a target DC.  In this case the operations done on the dc
+    will only be written to the buffer bitmap and *not* to any window, so
+    you will want to have provided the buffer bitmap and then reuse it
+    when it needs painted to the window.
+
+    Please note that GTK+ 2.0 and OS X provide double buffering themselves
+    natively.  You may want to use `wx.Window.IsDoubleBuffered` to
+    determine whether you need to use buffering or not, or use
+    `wx.AutoBufferedPaintDC` to avoid needless double buffering on systems
+    that already do it automatically.
+
+
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        """
+        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+
+        Constructs a buffered DC.
+        """
+        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
+        # save a ref so the other dc will not be deleted before self
+        self.__dc = args[0] 
+        # also save a ref to the bitmap
+        if len(args) > 1: self.__bmp = args[1]
+
+
+    __swig_destroy__ = _gdi_.delete_BufferedDC
+    __del__ = lambda self : None;
+    def UnMask(*args, **kwargs):
+        """
+        UnMask(self)
+
+        Blits the buffer to the dc, and detaches the dc from the buffer (so it
+        can be effectively used once only).  This is usually only called in
+        the destructor.
+        """
+        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
+
+    def SetStyle(*args, **kwargs):
+        """SetStyle(self, int style)"""
+        return _gdi_.BufferedDC_SetStyle(*args, **kwargs)
+
+    def GetStyle(*args, **kwargs):
+        """GetStyle(self) -> int"""
+        return _gdi_.BufferedDC_GetStyle(*args, **kwargs)
+
+_gdi_.BufferedDC_swigregister(BufferedDC)
+
+class BufferedPaintDC(BufferedDC):
+    """
+    This is a subclass of `wx.BufferedDC` which can be used inside of an
+    EVT_PAINT event handler. Just create an object of this class instead
+    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
+    flicker. The only thing to watch out for is that if you are using this
+    class together with `wx.ScrolledWindow`, you probably do **not** want
+    to call `wx.Window.PrepareDC` on it as it already does this internally
+    for the real underlying `wx.PaintDC`.
+
+    If your window is already fully buffered in a `wx.Bitmap` then your
+    EVT_PAINT handler can be as simple as just creating a
+    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
+    automatically when it is destroyed.  For example::
+
+        def OnPaint(self, event):
+            dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
+
+        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
+        provide the bitmap to be used for buffering or let this object create
+        one internally (in the latter case, the size of the client part of the
+        window is automatically used).
+        """
+        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
+        if len(args) > 1: self.__bmp = args[1]
+
+_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
+
+#---------------------------------------------------------------------------
+
+class AutoBufferedPaintDC(DC):
+    """
+    If the current platform double buffers by default then this DC is the
+    same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
+
+    :see: `wx.AutoBufferedPaintDCFactory`
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window win) -> AutoBufferedPaintDC
+
+        If the current platform double buffers by default then this DC is the
+        same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
+
+        :see: `wx.AutoBufferedPaintDCFactory`
+
+        """
+        _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
+_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
+
+
+def AutoBufferedPaintDCFactory(*args, **kwargs):
+  """
+    AutoBufferedPaintDCFactory(Window window) -> DC
+
+    Checks if the window is natively double buffered and will return a
+    `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise.  The advantage of
+    this function over `wx.AutoBufferedPaintDC` is that this function will check
+    if the the specified window has double-buffering enabled rather than just
+    going by platform defaults.
+    """
+  return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
+#---------------------------------------------------------------------------
+
+class MirrorDC(DC):
+    """
+    wx.MirrorDC is a simple wrapper class which is always associated with a
+    real `wx.DC` object and either forwards all of its operations to it
+    without changes (no mirroring takes place) or exchanges x and y
+    coordinates which makes it possible to reuse the same code to draw a
+    figure and its mirror -- i.e. reflection related to the diagonal line
+    x == y.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, DC dc, bool mirror) -> MirrorDC
+
+        Creates a mirrored DC associated with the real *dc*.  Everything drawn
+        on the wx.MirrorDC will appear on the *dc*, and will be mirrored if
+        *mirror* is True.
+        """
+        _gdi_.MirrorDC_swiginit(self,_gdi_.new_MirrorDC(*args, **kwargs))
+_gdi_.MirrorDC_swigregister(MirrorDC)
+
+#---------------------------------------------------------------------------
+
+class PostScriptDC(DC):
+    """This is a `wx.DC` that can write to PostScript files on any platform."""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, wxPrintData printData) -> PostScriptDC
+
+        Constructs a PostScript printer device context from a `wx.PrintData`
+        object.
+        """
+        _gdi_.PostScriptDC_swiginit(self,_gdi_.new_PostScriptDC(*args, **kwargs))
+    def GetPrintData(*args, **kwargs):
+        """GetPrintData(self) -> wxPrintData"""
+        return _gdi_.PostScriptDC_GetPrintData(*args, **kwargs)
+
+    def SetPrintData(*args, **kwargs):
+        """SetPrintData(self, wxPrintData data)"""
+        return _gdi_.PostScriptDC_SetPrintData(*args, **kwargs)
+
+    def SetResolution(*args, **kwargs):
+        """
+        SetResolution(int ppi)
+
+        Set resolution (in pixels per inch) that will be used in PostScript
+        output. Default is 720ppi.
+        """
+        return _gdi_.PostScriptDC_SetResolution(*args, **kwargs)
+
+    SetResolution = staticmethod(SetResolution)
+    def GetResolution(*args, **kwargs):
+        """
+        GetResolution() -> int
+
+        Return resolution used in PostScript output.
+        """
+        return _gdi_.PostScriptDC_GetResolution(*args, **kwargs)
+
+    GetResolution = staticmethod(GetResolution)
+    PrintData = property(GetPrintData,SetPrintData,doc="See `GetPrintData` and `SetPrintData`") 
+_gdi_.PostScriptDC_swigregister(PostScriptDC)
+
+def PostScriptDC_SetResolution(*args, **kwargs):
+  """
+    PostScriptDC_SetResolution(int ppi)
+
+    Set resolution (in pixels per inch) that will be used in PostScript
+    output. Default is 720ppi.
+    """
+  return _gdi_.PostScriptDC_SetResolution(*args, **kwargs)
+
+def PostScriptDC_GetResolution(*args):
+  """
+    PostScriptDC_GetResolution() -> int
+
+    Return resolution used in PostScript output.
+    """
+  return _gdi_.PostScriptDC_GetResolution(*args)
+
+#---------------------------------------------------------------------------
+
+class MetaFile(_core.Object):
+    """Proxy of C++ MetaFile class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """__init__(self, String filename=EmptyString) -> MetaFile"""
+        _gdi_.MetaFile_swiginit(self,_gdi_.new_MetaFile(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_MetaFile
+    __del__ = lambda self : None;
+    def IsOk(*args, **kwargs):
+        """IsOk(self) -> bool"""
+        return _gdi_.MetaFile_IsOk(*args, **kwargs)
+
+    Ok = IsOk 
+    def SetClipboard(*args, **kwargs):
+        """SetClipboard(self, int width=0, int height=0) -> bool"""
+        return _gdi_.MetaFile_SetClipboard(*args, **kwargs)
 
     def GetSize(*args, **kwargs):
         """GetSize(self) -> Size"""
@@ -4847,7 +5046,7 @@ class MetaFile(_core.Object):
         """GetFileName(self) -> String"""
         return _gdi_.MetaFile_GetFileName(*args, **kwargs)
 
-    def __nonzero__(self): return self.Ok() 
+    def __nonzero__(self): return self.IsOk() 
 _gdi_.MetaFile_swigregister(MetaFile)
 
 class MetaFileDC(DC):
@@ -4864,276 +5063,1013 @@ class MetaFileDC(DC):
         """Close(self) -> MetaFile"""
         return _gdi_.MetaFileDC_Close(*args, **kwargs)
 
-_gdi_.MetaFileDC_swigregister(MetaFileDC)
+_gdi_.MetaFileDC_swigregister(MetaFileDC)
+
+class PrinterDC(DC):
+    """Proxy of C++ PrinterDC class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """__init__(self, wxPrintData printData) -> PrinterDC"""
+        _gdi_.PrinterDC_swiginit(self,_gdi_.new_PrinterDC(*args, **kwargs))
+_gdi_.PrinterDC_swigregister(PrinterDC)
+
+#---------------------------------------------------------------------------
+
+class GraphicsObject(_core.Object):
+    """
+    This class is the superclass of native graphics objects like pens
+    etc. It provides the internal reference counting.  It is not to be
+    instantiated by user code.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, GraphicsRenderer renderer=None) -> GraphicsObject
+
+        This class is the superclass of native graphics objects like pens
+        etc. It provides the internal reference counting.  It is not to be
+        instantiated by user code.
+        """
+        _gdi_.GraphicsObject_swiginit(self,_gdi_.new_GraphicsObject(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsObject
+    __del__ = lambda self : None;
+    def IsNull(*args, **kwargs):
+        """
+        IsNull(self) -> bool
+
+        Is this object valid (false) or still empty (true)?
+        """
+        return _gdi_.GraphicsObject_IsNull(*args, **kwargs)
+
+    def GetRenderer(*args, **kwargs):
+        """
+        GetRenderer(self) -> GraphicsRenderer
+
+        Returns the renderer that was used to create this instance, or
+        ``None`` if it has not been initialized yet.
+        """
+        return _gdi_.GraphicsObject_GetRenderer(*args, **kwargs)
+
+_gdi_.GraphicsObject_swigregister(GraphicsObject)
+
+class GraphicsPen(GraphicsObject):
+    """
+    A wx.GraphicsPen is a native representation of a pen. It is used for
+    stroking a path on a `wx.GraphicsContext`. The contents are specific and
+    private to the respective renderer. The only way to get a valid instance
+    is via a CreatePen call on the graphics context or the renderer
+    instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsPen
+
+        A wx.GraphicsPen is a native representation of a pen. It is used for
+        stroking a path on a `wx.GraphicsContext`. The contents are specific and
+        private to the respective renderer. The only way to get a valid instance
+        is via a CreatePen call on the graphics context or the renderer
+        instance.
+        """
+        _gdi_.GraphicsPen_swiginit(self,_gdi_.new_GraphicsPen(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsPen
+    __del__ = lambda self : None;
+_gdi_.GraphicsPen_swigregister(GraphicsPen)
+
+class GraphicsBrush(GraphicsObject):
+    """
+    A wx.GraphicsBrush is a native representation of a brush. It is used
+    for filling a path on a `wx.GraphicsContext`. The contents are
+    specific and private to the respective renderer. The only way to get a
+    valid instance is via a Create...Brush call on the graphics context or
+    the renderer instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsBrush
+
+        A wx.GraphicsBrush is a native representation of a brush. It is used
+        for filling a path on a `wx.GraphicsContext`. The contents are
+        specific and private to the respective renderer. The only way to get a
+        valid instance is via a Create...Brush call on the graphics context or
+        the renderer instance.
+        """
+        _gdi_.GraphicsBrush_swiginit(self,_gdi_.new_GraphicsBrush(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsBrush
+    __del__ = lambda self : None;
+_gdi_.GraphicsBrush_swigregister(GraphicsBrush)
+
+class GraphicsFont(GraphicsObject):
+    """
+    A `wx.GraphicsFont` is a native representation of a font (including
+    text colour). The contents are specific an private to the respective
+    renderer.  The only way to get a valid instance is via a CreateFont
+    call on the graphics context or the renderer instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsFont
+
+        A `wx.GraphicsFont` is a native representation of a font (including
+        text colour). The contents are specific an private to the respective
+        renderer.  The only way to get a valid instance is via a CreateFont
+        call on the graphics context or the renderer instance.
+        """
+        _gdi_.GraphicsFont_swiginit(self,_gdi_.new_GraphicsFont(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsFont
+    __del__ = lambda self : None;
+_gdi_.GraphicsFont_swigregister(GraphicsFont)
+
+class GraphicsMatrix(GraphicsObject):
+    """
+    A wx.GraphicsMatrix is a native representation of an affine
+    matrix. The contents are specific an private to the respective
+    renderer. The only way to get a valid instance is via a CreateMatrix
+    call on the graphics context or the renderer instance.
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self) -> GraphicsMatrix
+
+        A wx.GraphicsMatrix is a native representation of an affine
+        matrix. The contents are specific an private to the respective
+        renderer. The only way to get a valid instance is via a CreateMatrix
+        call on the graphics context or the renderer instance.
+        """
+        _gdi_.GraphicsMatrix_swiginit(self,_gdi_.new_GraphicsMatrix(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsMatrix
+    __del__ = lambda self : None;
+    def Concat(*args, **kwargs):
+        """
+        Concat(self, GraphicsMatrix t)
+
+        Concatenates the passed in matrix to the current matrix.
+        """
+        return _gdi_.GraphicsMatrix_Concat(*args, **kwargs)
+
+    def Set(*args, **kwargs):
+        """
+        Set(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0, 
+            Double tx=0.0, Double ty=0.0)
+
+        Sets the matrix to the specified values (default values are the
+        identity matrix.)
+        """
+        return _gdi_.GraphicsMatrix_Set(*args, **kwargs)
+
+    def Invert(*args, **kwargs):
+        """
+        Invert(self)
+
+        Inverts the matrix.
+        """
+        return _gdi_.GraphicsMatrix_Invert(*args, **kwargs)
+
+    def IsEqual(*args, **kwargs):
+        """
+        IsEqual(self, GraphicsMatrix t) -> bool
+
+        Returns ``True`` if the elements of the transformation matrix are equal
+        """
+        return _gdi_.GraphicsMatrix_IsEqual(*args, **kwargs)
+
+    def IsIdentity(*args, **kwargs):
+        """
+        IsIdentity(self) -> bool
+
+        Returns ``True`` if this is the identity matrix
+        """
+        return _gdi_.GraphicsMatrix_IsIdentity(*args, **kwargs)
+
+    def Translate(*args, **kwargs):
+        """
+        Translate(self, Double dx, Double dy)
+
+        Add a translation to this matrix.
+        """
+        return _gdi_.GraphicsMatrix_Translate(*args, **kwargs)
+
+    def Scale(*args, **kwargs):
+        """
+        Scale(self, Double xScale, Double yScale)
+
+        Scales this matrix.
+        """
+        return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)
+
+    def Rotate(*args, **kwargs):
+        """
+        Rotate(self, Double angle)
+
+        Rotates this matrix.  The angle should be specified in radians.
+        """
+        return _gdi_.GraphicsMatrix_Rotate(*args, **kwargs)
+
+    def TransformPoint(*args, **kwargs):
+        """
+        TransformPoint(self, x, y) --> (x, y)
+
+        Applies this matrix to a point, returns the resulting point values
+        """
+        return _gdi_.GraphicsMatrix_TransformPoint(*args, **kwargs)
+
+    def TransformDistance(*args, **kwargs):
+        """
+        TransformDistance(self, dx, dy) --> (dx, dy)
+
+        Applies this matrix to a distance (ie. performs all transforms except
+        translations)
+        """
+        return _gdi_.GraphicsMatrix_TransformDistance(*args, **kwargs)
+
+    def GetNativeMatrix(*args, **kwargs):
+        """
+        GetNativeMatrix(self) -> void
+
+        Returns the native representation of the matrix. For CoreGraphics this
+        is a CFAffineMatrix pointer. For GDIPlus a Matrix Pointer and for
+        Cairo a cairo_matrix_t pointer.  NOTE: For wxPython we still need a
+        way to make this value usable.
+        """
+        return _gdi_.GraphicsMatrix_GetNativeMatrix(*args, **kwargs)
+
+_gdi_.GraphicsMatrix_swigregister(GraphicsMatrix)
+
+class GraphicsPath(GraphicsObject):
+    """Proxy of C++ GraphicsPath class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """__init__(self) -> GraphicsPath"""
+        _gdi_.GraphicsPath_swiginit(self,_gdi_.new_GraphicsPath(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_GraphicsPath
+    __del__ = lambda self : None;
+    def MoveToPoint(*args):
+        """
+        MoveToPoint(self, Double x, Double y)
+        MoveToPoint(self, Point2D p)
+
+        Begins a new subpath at the specified point.
+        """
+        return _gdi_.GraphicsPath_MoveToPoint(*args)
+
+    def AddLineToPoint(*args):
+        """
+        AddLineToPoint(self, Double x, Double y)
+        AddLineToPoint(self, Point2D p)
+
+        Adds a straight line from the current point to the specified point.
+        """
+        return _gdi_.GraphicsPath_AddLineToPoint(*args)
+
+    def AddCurveToPoint(*args):
+        """
+        AddCurveToPoint(self, Double cx1, Double cy1, Double cx2, Double cy2, Double x, 
+            Double y)
+        AddCurveToPoint(self, Point2D c1, Point2D c2, Point2D e)
+
+        Adds a cubic Bezier curve from the current point, using two control
+        points and an end point
+        """
+        return _gdi_.GraphicsPath_AddCurveToPoint(*args)
+
+    def AddPath(*args, **kwargs):
+        """
+        AddPath(self, GraphicsPath path)
+
+        Adds another path
+        """
+        return _gdi_.GraphicsPath_AddPath(*args, **kwargs)
+
+    def CloseSubpath(*args, **kwargs):
+        """
+        CloseSubpath(self)
+
+        Closes the current sub-path.
+        """
+        return _gdi_.GraphicsPath_CloseSubpath(*args, **kwargs)
+
+    def GetCurrentPoint(*args, **kwargs):
+        """
+        GetCurrentPoint(self) -> Point2D
+
+        Gets the last point of the current path, (0,0) if not yet set
+        """
+        return _gdi_.GraphicsPath_GetCurrentPoint(*args, **kwargs)
+
+    def AddArc(*args):
+        """
+        AddArc(self, Double x, Double y, Double r, Double startAngle, Double endAngle, 
+            bool clockwise)
+        AddArc(self, Point2D c, Double r, Double startAngle, Double endAngle, 
+            bool clockwise)
+
+        Adds an arc of a circle centering at (x,y) with radius (r) from
+        startAngle to endAngle
+        """
+        return _gdi_.GraphicsPath_AddArc(*args)
+
+    def AddQuadCurveToPoint(*args, **kwargs):
+        """
+        AddQuadCurveToPoint(self, Double cx, Double cy, Double x, Double y)
+
+        Adds a quadratic Bezier curve from the current point, using a control
+        point and an end point
+        """
+        return _gdi_.GraphicsPath_AddQuadCurveToPoint(*args, **kwargs)
+
+    def AddRectangle(*args, **kwargs):
+        """
+        AddRectangle(self, Double x, Double y, Double w, Double h)
+
+        Appends a rectangle as a new closed subpath.
+        """
+        return _gdi_.GraphicsPath_AddRectangle(*args, **kwargs)
+
+    def AddCircle(*args, **kwargs):
+        """
+        AddCircle(self, Double x, Double y, Double r)
+
+        Appends a circle around (x,y) with radius r as a new closed subpath.
+        """
+        return _gdi_.GraphicsPath_AddCircle(*args, **kwargs)
+
+    def AddArcToPoint(*args, **kwargs):
+        """
+        AddArcToPoint(self, Double x1, Double y1, Double x2, Double y2, Double r)
+
+        Appends an arc to two tangents connecting (current) to (x1,y1) and (x1,y1)
+        to (x2,y2), also a straight line from (current) to (x1,y1)
+        """
+        return _gdi_.GraphicsPath_AddArcToPoint(*args, **kwargs)
+
+    def AddEllipse(*args, **kwargs):
+        """
+        AddEllipse(self, Double x, Double y, Double w, Double h)
+
+        Appends an ellipse fitting into the passed in rectangle.
+        """
+        return _gdi_.GraphicsPath_AddEllipse(*args, **kwargs)
+
+    def AddRoundedRectangle(*args, **kwargs):
+        """
+        AddRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)
+
+        Appends a rounded rectangle.
+        """
+        return _gdi_.GraphicsPath_AddRoundedRectangle(*args, **kwargs)
+
+    def GetNativePath(*args, **kwargs):
+        """
+        GetNativePath(self) -> void
+
+        Returns the native path (CGPathRef for Core Graphics, Path pointer for
+        GDIPlus and a cairo_path_t pointer for cairo).  NOTE: For wxPython we
+        still need a way to make this value usable.
+        """
+        return _gdi_.GraphicsPath_GetNativePath(*args, **kwargs)
+
+    def UnGetNativePath(*args, **kwargs):
+        """
+        UnGetNativePath(self, void p)
+
+        Gives back the native path returned by GetNativePath() because there
+        might be some deallocations necessary (eg on cairo the native path
+        returned by GetNativePath is newly allocated each time).
+        """
+        return _gdi_.GraphicsPath_UnGetNativePath(*args, **kwargs)
+
+    def Transform(*args, **kwargs):
+        """
+        Transform(self, GraphicsMatrix matrix)
+
+        Transforms each point of this path by the matrix
+        """
+        return _gdi_.GraphicsPath_Transform(*args, **kwargs)
+
+    def GetBox(*args, **kwargs):
+        """
+        GetBox(self) -> wxRect2DDouble
+
+        Gets the bounding box enclosing all points (possibly including control points)
+        """
+        return _gdi_.GraphicsPath_GetBox(*args, **kwargs)
 
-class PrinterDC(DC):
-    """Proxy of C++ PrinterDC class"""
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """__init__(self, wxPrintData printData) -> PrinterDC"""
-        _gdi_.PrinterDC_swiginit(self,_gdi_.new_PrinterDC(*args, **kwargs))
-_gdi_.PrinterDC_swigregister(PrinterDC)
+    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)
 
-class GraphicsPath(object):
-    """Proxy of C++ GraphicsPath class"""
+_gdi_.GraphicsPath_swigregister(GraphicsPath)
+
+class GraphicsContext(GraphicsObject):
+    """
+    A `wx.GraphicsContext` instance is the object that is drawn upon. It is
+    created by a renderer using the CreateContext calls, this can be done
+    either directly using a renderer instance, or indirectly using the
+    static convenience CreateXXX functions of wx.GraphicsContext that
+    always delegate the task to the default renderer.
+    """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     def __init__(self): raise AttributeError, "No constructor defined"
     __repr__ = _swig_repr
-    __swig_destroy__ = _gdi_.delete_GraphicsPath
+    __swig_destroy__ = _gdi_.delete_GraphicsContext
     __del__ = lambda self : None;
-    def MoveToPoint(*args, **kwargs):
+    def Create(*args):
         """
-        MoveToPoint(self, Double x, Double y)
+        Create(WindowDC dc) -> GraphicsContext
+        Create(Window window) -> GraphicsContext
 
-        Begins a new subpath at (x,y)
+        Creates a wx.GraphicsContext either from a window or a DC.
         """
-        return _gdi_.GraphicsPath_MoveToPoint(*args, **kwargs)
+        val = _gdi_.GraphicsContext_Create(*args)
+        val.__dc = args[0] # save a ref so the dc will not be deleted before self
+        return val
 
-    def AddLineToPoint(*args, **kwargs):
+    Create = staticmethod(Create)
+    def CreateMeasuringContext(*args):
         """
-        AddLineToPoint(self, Double x, Double y)
+        CreateMeasuringContext() -> GraphicsContext
 
-        Adds a straight line from the current point to (x,y) 
+        Create a lightwieght context that can be used for measuring text only.
         """
-        return _gdi_.GraphicsPath_AddLineToPoint(*args, **kwargs)
+        val = _gdi_.GraphicsContext_CreateMeasuringContext(*args)
+        val.__dc = args[0] # save a ref so the dc will not be deleted before self
+        return val
 
-    def AddCurveToPoint(*args, **kwargs):
+    CreateMeasuringContext = staticmethod(CreateMeasuringContext)
+    def CreateFromNative(*args, **kwargs):
         """
-        AddCurveToPoint(self, Double cx1, Double cy1, Double cx2, Double cy2, Double x, 
-            Double y)
+        CreateFromNative(void context) -> GraphicsContext
 
-        Adds a cubic Bezier curve from the current point, using two control
-        points and an end point
+        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_.GraphicsPath_AddCurveToPoint(*args, **kwargs)
+        return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs)
 
-    def CloseSubpath(*args, **kwargs):
+    CreateFromNative = staticmethod(CreateFromNative)
+    def CreateFromNativeWindow(*args, **kwargs):
         """
-        CloseSubpath(self)
+        CreateFromNativeWindow(void window) -> GraphicsContext
 
-        closes the current sub-path
+        Creates a wx.GraphicsContext from a native window.
         """
-        return _gdi_.GraphicsPath_CloseSubpath(*args, **kwargs)
+        return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs)
 
-    def GetCurrentPoint(*args, **kwargs):
+    CreateFromNativeWindow = staticmethod(CreateFromNativeWindow)
+    def CreatePath(*args, **kwargs):
         """
-        GetCurrentPoint(self) -> Point2D
+        CreatePath(self) -> GraphicsPath
 
-        Gets the last point of the current path, (0,0) if not yet set
+        Creates a native graphics path which is initially empty.
         """
-        return _gdi_.GraphicsPath_GetCurrentPoint(*args, **kwargs)
+        return _gdi_.GraphicsContext_CreatePath(*args, **kwargs)
 
-    def AddArc(*args, **kwargs):
+    def CreatePen(*args, **kwargs):
         """
-        AddArc(self, Double x, Double y, Double r, Double startAngle, Double endAngle, 
-            bool clockwise)
+        CreatePen(self, Pen pen) -> GraphicsPen
 
-        Adds an arc of a circle centering at (x,y) with radius (r) from
-        startAngle to endAngle
+        Creates a native pen from a `wx.Pen`.
         """
-        return _gdi_.GraphicsPath_AddArc(*args, **kwargs)
+        return _gdi_.GraphicsContext_CreatePen(*args, **kwargs)
 
-    def AddQuadCurveToPoint(*args, **kwargs):
+    def CreateBrush(*args, **kwargs):
         """
-        AddQuadCurveToPoint(self, Double cx, Double cy, Double x, Double y)
+        CreateBrush(self, Brush brush) -> GraphicsBrush
 
-        Adds a quadratic Bezier curve from the current point, using a control
-        point and an end point
+        Creates a native brush from a `wx.Brush`.
         """
-        return _gdi_.GraphicsPath_AddQuadCurveToPoint(*args, **kwargs)
+        return _gdi_.GraphicsContext_CreateBrush(*args, **kwargs)
 
-    def AddRectangle(*args, **kwargs):
+    def CreateLinearGradientBrush(*args, **kwargs):
         """
-        AddRectangle(self, Double x, Double y, Double w, Double h)
+        CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1, 
+            Colour c2) -> GraphicsBrush
 
-        Appends a rectangle as a new closed subpath
+        Creates a native brush, having a linear gradient, starting at (x1,y1)
+        with color c1 to (x2,y2) with color c2.
         """
-        return _gdi_.GraphicsPath_AddRectangle(*args, **kwargs)
+        return _gdi_.GraphicsContext_CreateLinearGradientBrush(*args, **kwargs)
 
-    def AddCircle(*args, **kwargs):
+    def CreateRadialGradientBrush(*args, **kwargs):
         """
-        AddCircle(self, Double x, Double y, Double r)
+        CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius, 
+            Colour oColor, Colour cColor) -> GraphicsBrush
 
-        Appends an ellipsis as a new closed subpath fitting the passed rectangle
+        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_.GraphicsPath_AddCircle(*args, **kwargs)
+        return _gdi_.GraphicsContext_CreateRadialGradientBrush(*args, **kwargs)
 
-    def AddArcToPoint(*args, **kwargs):
+    def CreateFont(*args, **kwargs):
         """
-        AddArcToPoint(self, Double x1, Double y1, Double x2, Double y2, Double r)
+        CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont
 
-        Draws a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1)
-        to (x2,y2), also a straight line from (current) to (x1,y1)
+        Creates a native graphics font from a `wx.Font` and a text colour.
         """
-        return _gdi_.GraphicsPath_AddArcToPoint(*args, **kwargs)
-
-_gdi_.GraphicsPath_swigregister(GraphicsPath)
+        return _gdi_.GraphicsContext_CreateFont(*args, **kwargs)
 
-class GraphicsContext(object):
-    """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
-        return val
+    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 = staticmethod(Create)
-    def CreatePath(*args, **kwargs):
-        """CreatePath(self) -> GraphicsPath"""
-        return _gdi_.GraphicsContext_CreatePath(*args, **kwargs)
+        Creates a native affine transformation matrix from the passed in
+        values. The defaults result in an identity matrix.
+        """
+        return _gdi_.GraphicsContext_CreateMatrix(*args, **kwargs)
 
     def PushState(*args, **kwargs):
-        """PushState(self)"""
+        """
+        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, combined to current clipping 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 rectangle.
+        """
         return _gdi_.GraphicsContext_Clip(*args, **kwargs)
 
+    def ResetClip(*args, **kwargs):
+        """
+        ResetClip(self)
+
+        Resets the clipping to original shape.
+        """
+        return _gdi_.GraphicsContext_ResetClip(*args, **kwargs)
+
+    def GetNativeContext(*args, **kwargs):
+        """
+        GetNativeContext(self) -> void
+
+        Returns the native context (CGContextRef for Core Graphics, Graphics
+        pointer for GDIPlus and cairo_t pointer for cairo).
+        """
+        return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs)
+
+    def GetLogicalFunction(*args, **kwargs):
+        """
+        GetLogicalFunction(self) -> int
+
+        Returns the current logical function.
+        """
+        return _gdi_.GraphicsContext_GetLogicalFunction(*args, **kwargs)
+
+    def SetLogicalFunction(*args, **kwargs):
+        """
+        SetLogicalFunction(self, int function) -> bool
+
+        Sets the current logical function, returns ``True`` if it supported
+        """
+        return _gdi_.GraphicsContext_SetLogicalFunction(*args, **kwargs)
+
     def Translate(*args, **kwargs):
-        """Translate(self, Double dx, Double dy)"""
+        """
+        Translate(self, Double dx, Double dy)
+
+        Translates the current transformation matrix.
+        """
         return _gdi_.GraphicsContext_Translate(*args, **kwargs)
 
     def Scale(*args, **kwargs):
-        """Scale(self, Double xScale, Double yScale)"""
+        """
+        Scale(self, Double xScale, Double yScale)
+
+        Scale the current transformation matrix of the context.
+        """
         return _gdi_.GraphicsContext_Scale(*args, **kwargs)
 
     def Rotate(*args, **kwargs):
-        """Rotate(self, Double angle)"""
+        """
+        Rotate(self, Double angle)
+
+        Rotate the current transformation matrix of the context.  ``angle`` is
+        specified in radians.
+        """
         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 SetBrush(*args):
+        """
+        SetBrush(self, GraphicsBrush brush)
+        SetBrush(self, Brush brush)
+
+        Sets the brush for filling
+        """
+        return _gdi_.GraphicsContext_SetBrush(*args)
 
-    def SetTextColor(*args, **kwargs):
-        """SetTextColor(self, Colour col)"""
-        return _gdi_.GraphicsContext_SetTextColor(*args, **kwargs)
+    def SetFont(*args):
+        """
+        SetFont(self, GraphicsFont font)
+        SetFont(self, Font font, Colour colour=*wxBLACK)
+
+        Sets the font
+        """
+        return _gdi_.GraphicsContext_SetFont(*args)
 
     def StrokePath(*args, **kwargs):
-        """StrokePath(self, GraphicsPath path)"""
+        """
+        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 the path by first filling and then stroking.
+        """
         return _gdi_.GraphicsContext_DrawPath(*args, **kwargs)
 
-    def DrawText(*args):
+    def DrawText(*args, **kwargs):
+        """
+        DrawText(self, String str, Double x, Double y, GraphicsBrush backgroundBrush=NullGraphicsBrush)
+
+        Draws a text string at the defined position.
+        """
+        return _gdi_.GraphicsContext_DrawText(*args, **kwargs)
+
+    def DrawRotatedText(*args, **kwargs):
+        """
+        DrawRotatedText(self, String str, Double x, Double y, Double angle, GraphicsBrush backgroundBrush=NullGraphicsBrush)
+
+        Draws a text string at the defined position, at the specified angle,
+        which is given in radians.
         """
-        DrawText(self, String str, Double x, Double y)
-        DrawText(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)
+
+        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_DrawText(*args)
+        return _gdi_.GraphicsContext_GetFullTextExtent(*args, **kwargs)
 
     def GetTextExtent(*args, **kwargs):
         """
-        GetTextExtent(self, String text, Double OUTPUT, Double OUTPUT, Double OUTPUT, 
-            Double OUTPUT)
+        GetTextExtent(self, text) --> (width, height)
+
+        Gets the dimensions of the string using the currently selected
+        font. ``text`` is the string to measure, ``w`` and ``h`` are the total
+        width and height respectively.
         """
         return _gdi_.GraphicsContext_GetTextExtent(*args, **kwargs)
 
     def GetPartialTextExtents(*args, **kwargs):
-        """GetPartialTextExtents(self, String text, wxArrayDouble 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):
-        """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):
-        """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):
-        """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):
+    def StrokeLines(*args, **kwargs):
+        """
+        StrokeLines(self, List points)
+
+        Stroke lines connecting each of the points
         """
-        StrokeLines(self, size_t n, Point2D points)
-        StrokeLines(self, size_t n, Point2D beginPoints, Point2D endPoints)
+        return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs)
+
+    def StrokeLineSegements(*args, **kwargs):
+        """
+        StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints)
+
+        Stroke disconnected lines from begin to end points
         """
-        return _gdi_.GraphicsContext_StrokeLines(*args)
+        return _gdi_.GraphicsContext_StrokeLineSegements(*args, **kwargs)
 
     def DrawLines(*args, **kwargs):
-        """DrawLines(self, size_t n, Point2D 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):
+  """
+    Create(WindowDC dc) -> GraphicsContext
+    GraphicsContext_Create(Window window) -> GraphicsContext
+
+    Creates a wx.GraphicsContext either from a window or a DC.
+    """
+  val = _gdi_.GraphicsContext_Create(*args)
+  val.__dc = args[0] # save a ref so the dc will not be deleted before self
+  return val
+
+def GraphicsContext_CreateMeasuringContext(*args):
+  """
+    GraphicsContext_CreateMeasuringContext() -> GraphicsContext
 
-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
+    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):
+  """
+    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)
+
+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
-    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
     __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):
+    """Proxy of C++ Overlay class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """__init__(self) -> Overlay"""
+        _gdi_.Overlay_swiginit(self,_gdi_.new_Overlay(*args, **kwargs))
+    __swig_destroy__ = _gdi_.delete_Overlay
+    __del__ = lambda self : None;
+    def Reset(*args, **kwargs):
+        """Reset(self)"""
+        return _gdi_.Overlay_Reset(*args, **kwargs)
+
+_gdi_.Overlay_swigregister(Overlay)
+
+class DCOverlay(object):
+    """Proxy of C++ DCOverlay class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        """
+        __init__(self, Overlay overlay, WindowDC dc, int x, int y, int width, 
+            int height) -> DCOverlay
+        __init__(self, Overlay overlay, WindowDC dc) -> DCOverlay
+        """
+        _gdi_.DCOverlay_swiginit(self,_gdi_.new_DCOverlay(*args))
+    __swig_destroy__ = _gdi_.delete_DCOverlay
+    __del__ = lambda self : None;
+    def Clear(*args, **kwargs):
+        """Clear(self)"""
+        return _gdi_.DCOverlay_Clear(*args, **kwargs)
+
+_gdi_.DCOverlay_swigregister(DCOverlay)
+
 #---------------------------------------------------------------------------
 
 IMAGELIST_DRAW_NORMAL = _gdi_.IMAGELIST_DRAW_NORMAL
@@ -5409,7 +6345,6 @@ class GDIObjListBase(object):
     __swig_destroy__ = _gdi_.delete_GDIObjListBase
     __del__ = lambda self : None;
 _gdi_.GDIObjListBase_swigregister(GDIObjListBase)
-cvar = _gdi_.cvar
 NullBitmap = cvar.NullBitmap
 NullIcon = cvar.NullIcon
 NullCursor = cvar.NullCursor
@@ -5754,17 +6689,17 @@ class RendererNative(object):
     def DrawHeaderButton(*args, **kwargs):
         """
         DrawHeaderButton(self, Window win, DC dc, Rect rect, int flags=0, int sortArrow=HDR_SORT_ICON_NONE, 
-            HeaderButtonParams params=None)
+            HeaderButtonParams params=None) -> int
 
-        Draw the header control button (such as what is used by `wx.ListCtrl`
-        in report mode.)
+        Draw a header control button (such as what is used by `wx.ListCtrl` in report
+        mode.)  The optimal size of the label (text and icons) is returned.
         """
         return _gdi_.RendererNative_DrawHeaderButton(*args, **kwargs)
 
     def DrawHeaderButtonContents(*args, **kwargs):
         """
         DrawHeaderButtonContents(self, Window win, DC dc, Rect rect, int flags=0, int sortArrow=HDR_SORT_ICON_NONE, 
-            HeaderButtonParams params=None)
+            HeaderButtonParams params=None) -> int
 
         Draw the contents of a header control button, (label, sort
         arrows, etc.)  Normally this is only called by `DrawHeaderButton`.