relay mouse move events to the tooltips even when the window itself doesn't have...

[wxWidgets.git] / wxPython / src / gtk / grid.py

diff --git a/wxPython/src/gtk/grid.py b/wxPython/src/gtk/grid.py
index 259d15e93c4d3a3649b955bcd28e4683a76a8833..4cb321f50a32b5373c2a1eeaada232c728996ad8 100644 (file)
--- a/wxPython/src/gtk/grid.py
+++ b/wxPython/src/gtk/grid.py
@@ -1,11 +1,64 @@
-# This file was created automatically by SWIG.
+# This file was created automatically by SWIG 1.3.29.

 # Don't modify this file, modify the SWIG interface instead.
 
 # Don't modify this file, modify the SWIG interface instead.
 

-import _grid
+"""
+Classes for implementing a spreadsheet-like control.
+"""

 
 

-import windows
-import core
-wx = core 
+import _grid
+import new
+new_instancemethod = new.instancemethod
+def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
+    if (name == "thisown"): return self.this.own(value)
+    if (name == "this"):
+        if type(value).__name__ == 'PySwigObject':
+            self.__dict__[name] = value
+            return
+    method = class_type.__swig_setmethods__.get(name,None)
+    if method: return method(self,value)
+    if (not static) or hasattr(self,name):
+        self.__dict__[name] = value
+    else:
+        raise AttributeError("You cannot add attributes to %s" % self)
+
+def _swig_setattr(self,class_type,name,value):
+    return _swig_setattr_nondynamic(self,class_type,name,value,0)
+
+def _swig_getattr(self,class_type,name):
+    if (name == "thisown"): return self.this.own()
+    method = class_type.__swig_getmethods__.get(name,None)
+    if method: return method(self)
+    raise AttributeError,name
+
+def _swig_repr(self):
+    try: strthis = "proxy of " + self.this.__repr__()
+    except: strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+import types
+try:
+    _object = types.ObjectType
+    _newclass = 1
+except AttributeError:
+    class _object : pass
+    _newclass = 0
+del types
+
+
+def _swig_setattr_nondynamic_method(set):
+    def set_attr(self,name,value):
+        if (name == "thisown"): return self.this.own(value)
+        if hasattr(self,name) or (name == "this"):
+            set(self,name,value)
+        else:
+            raise AttributeError("You cannot add attributes to %s" % self)
+    return set_attr
+
+
+import _windows
+import _core
+wx = _core 
+__docfilter__ = wx.__DocFilter(globals()) 

 GRID_VALUE_STRING = _grid.GRID_VALUE_STRING
 GRID_VALUE_BOOL = _grid.GRID_VALUE_BOOL
 GRID_VALUE_NUMBER = _grid.GRID_VALUE_NUMBER
 GRID_VALUE_STRING = _grid.GRID_VALUE_STRING
 GRID_VALUE_BOOL = _grid.GRID_VALUE_BOOL
 GRID_VALUE_NUMBER = _grid.GRID_VALUE_NUMBER


@@ -15,552 +68,425 @@ GRID_VALUE_TEXT = _grid.GRID_VALUE_TEXT
 GRID_VALUE_LONG = _grid.GRID_VALUE_LONG
 GRID_VALUE_CHOICEINT = _grid.GRID_VALUE_CHOICEINT
 GRID_VALUE_DATETIME = _grid.GRID_VALUE_DATETIME
 GRID_VALUE_LONG = _grid.GRID_VALUE_LONG
 GRID_VALUE_CHOICEINT = _grid.GRID_VALUE_CHOICEINT
 GRID_VALUE_DATETIME = _grid.GRID_VALUE_DATETIME

-class GridCellRenderer(object):
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+GRID_DEFAULT_NUMBER_ROWS = _grid.GRID_DEFAULT_NUMBER_ROWS
+GRID_DEFAULT_NUMBER_COLS = _grid.GRID_DEFAULT_NUMBER_COLS
+GRID_DEFAULT_ROW_HEIGHT = _grid.GRID_DEFAULT_ROW_HEIGHT
+GRID_DEFAULT_COL_WIDTH = _grid.GRID_DEFAULT_COL_WIDTH
+GRID_DEFAULT_COL_LABEL_HEIGHT = _grid.GRID_DEFAULT_COL_LABEL_HEIGHT
+GRID_DEFAULT_ROW_LABEL_WIDTH = _grid.GRID_DEFAULT_ROW_LABEL_WIDTH
+GRID_LABEL_EDGE_ZONE = _grid.GRID_LABEL_EDGE_ZONE
+GRID_MIN_ROW_HEIGHT = _grid.GRID_MIN_ROW_HEIGHT
+GRID_MIN_COL_WIDTH = _grid.GRID_MIN_COL_WIDTH
+GRID_DEFAULT_SCROLLBAR_WIDTH = _grid.GRID_DEFAULT_SCROLLBAR_WIDTH
+class GridCellWorker(object):
+    """Proxy of C++ GridCellWorker class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    def __init__(self): raise AttributeError, "No constructor defined"
+    __repr__ = _swig_repr

     def _setOORInfo(*args, **kwargs):
     def _setOORInfo(*args, **kwargs):

-        """_setOORInfo(PyObject _self)"""
-        return _grid.GridCellRenderer__setOORInfo(*args, **kwargs)
+        """_setOORInfo(self, PyObject _self)"""
+        return _grid.GridCellWorker__setOORInfo(*args, **kwargs)

 
 

+    __swig_destroy__ = _grid.delete_GridCellWorker
+    __del__ = lambda self : None;

     def SetParameters(*args, **kwargs):
     def SetParameters(*args, **kwargs):

-        """SetParameters(String params)"""
-        return _grid.GridCellRenderer_SetParameters(*args, **kwargs)
+        """SetParameters(self, String params)"""
+        return _grid.GridCellWorker_SetParameters(*args, **kwargs)

 
     def IncRef(*args, **kwargs):
 
     def IncRef(*args, **kwargs):

-        """IncRef()"""
-        return _grid.GridCellRenderer_IncRef(*args, **kwargs)
+        """IncRef(self)"""
+        return _grid.GridCellWorker_IncRef(*args, **kwargs)

 
     def DecRef(*args, **kwargs):
 
     def DecRef(*args, **kwargs):

-        """DecRef()"""
-        return _grid.GridCellRenderer_DecRef(*args, **kwargs)
-
-    def Draw(*args, **kwargs):
-        """
-        Draw(Grid grid, GridCellAttr attr, DC dc, Rect rect, int row, 
-            int col, bool isSelected)
-        """
-        return _grid.GridCellRenderer_Draw(*args, **kwargs)
-
-    def GetBestSize(*args, **kwargs):
-        """GetBestSize(Grid grid, GridCellAttr attr, DC dc, int row, int col) -> Size"""
-        return _grid.GridCellRenderer_GetBestSize(*args, **kwargs)
-
-    def Clone(*args, **kwargs):
-        """Clone() -> GridCellRenderer"""
-        return _grid.GridCellRenderer_Clone(*args, **kwargs)
-
+        """DecRef(self)"""
+        return _grid.GridCellWorker_DecRef(*args, **kwargs)

 
 

-class GridCellRendererPtr(GridCellRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellRenderer
-_grid.GridCellRenderer_swigregister(GridCellRendererPtr)
+GridCellWorker_swigregister = _grid.GridCellWorker_swigregister
+GridCellWorker_swigregister(GridCellWorker)

 cvar = _grid.cvar
 cvar = _grid.cvar

-DateTimeFormatStr = cvar.DateTimeFormatStr

 GridNoCellCoords = cvar.GridNoCellCoords
 GridNoCellRect = cvar.GridNoCellRect
 
 GridNoCellCoords = cvar.GridNoCellCoords
 GridNoCellRect = cvar.GridNoCellRect
 

+class GridCellRenderer(GridCellWorker):
+    """Proxy of C++ GridCellRenderer 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
+GridCellRenderer_swigregister = _grid.GridCellRenderer_swigregister
+GridCellRenderer_swigregister(GridCellRenderer)
+

 class PyGridCellRenderer(GridCellRenderer):
 class PyGridCellRenderer(GridCellRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxPyGridCellRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> PyGridCellRenderer"""
-        newobj = _grid.new_PyGridCellRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ PyGridCellRenderer 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) -> PyGridCellRenderer"""
+        _grid.PyGridCellRenderer_swiginit(self,_grid.new_PyGridCellRenderer(*args, **kwargs))

         self._setCallbackInfo(self, PyGridCellRenderer);self._setOORInfo(self)
 
     def _setCallbackInfo(*args, **kwargs):
         self._setCallbackInfo(self, PyGridCellRenderer);self._setOORInfo(self)
 
     def _setCallbackInfo(*args, **kwargs):

-        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        """_setCallbackInfo(self, PyObject self, PyObject _class)"""

         return _grid.PyGridCellRenderer__setCallbackInfo(*args, **kwargs)
 
         return _grid.PyGridCellRenderer__setCallbackInfo(*args, **kwargs)
 

-    def base_SetParameters(*args, **kwargs):
-        """base_SetParameters(String params)"""
-        return _grid.PyGridCellRenderer_base_SetParameters(*args, **kwargs)
+    def SetParameters(*args, **kwargs):
+        """SetParameters(self, String params)"""
+        return _grid.PyGridCellRenderer_SetParameters(*args, **kwargs)

 
 

+    def base_SetParameters(*args, **kw):
+        return PyGridCellRenderer.SetParameters(*args, **kw)
+    base_SetParameters = wx._deprecated(base_SetParameters,
+                                   "Please use PyGridCellRenderer.SetParameters instead.")

 
 

-class PyGridCellRendererPtr(PyGridCellRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = PyGridCellRenderer
-_grid.PyGridCellRenderer_swigregister(PyGridCellRendererPtr)
+PyGridCellRenderer_swigregister = _grid.PyGridCellRenderer_swigregister
+PyGridCellRenderer_swigregister(PyGridCellRenderer)

 
 class GridCellStringRenderer(GridCellRenderer):
 
 class GridCellStringRenderer(GridCellRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellStringRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellStringRenderer"""
-        newobj = _grid.new_GridCellStringRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellStringRenderer 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) -> GridCellStringRenderer"""
+        _grid.GridCellStringRenderer_swiginit(self,_grid.new_GridCellStringRenderer(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-
-class GridCellStringRendererPtr(GridCellStringRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellStringRenderer
-_grid.GridCellStringRenderer_swigregister(GridCellStringRendererPtr)
+GridCellStringRenderer_swigregister = _grid.GridCellStringRenderer_swigregister
+GridCellStringRenderer_swigregister(GridCellStringRenderer)

 
 class GridCellNumberRenderer(GridCellStringRenderer):
 
 class GridCellNumberRenderer(GridCellStringRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellNumberRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellNumberRenderer"""
-        newobj = _grid.new_GridCellNumberRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellNumberRenderer 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) -> GridCellNumberRenderer"""
+        _grid.GridCellNumberRenderer_swiginit(self,_grid.new_GridCellNumberRenderer(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-
-class GridCellNumberRendererPtr(GridCellNumberRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellNumberRenderer
-_grid.GridCellNumberRenderer_swigregister(GridCellNumberRendererPtr)
+GridCellNumberRenderer_swigregister = _grid.GridCellNumberRenderer_swigregister
+GridCellNumberRenderer_swigregister(GridCellNumberRenderer)

 
 class GridCellFloatRenderer(GridCellStringRenderer):
 
 class GridCellFloatRenderer(GridCellStringRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellFloatRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(int width=-1, int precision=-1) -> GridCellFloatRenderer"""
-        newobj = _grid.new_GridCellFloatRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellFloatRenderer 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, int width=-1, int precision=-1) -> GridCellFloatRenderer"""
+        _grid.GridCellFloatRenderer_swiginit(self,_grid.new_GridCellFloatRenderer(*args, **kwargs))

         self._setOORInfo(self)
 
     def GetWidth(*args, **kwargs):
         self._setOORInfo(self)
 
     def GetWidth(*args, **kwargs):

-        """GetWidth() -> int"""
+        """GetWidth(self) -> int"""

         return _grid.GridCellFloatRenderer_GetWidth(*args, **kwargs)
 
     def SetWidth(*args, **kwargs):
         return _grid.GridCellFloatRenderer_GetWidth(*args, **kwargs)
 
     def SetWidth(*args, **kwargs):

-        """SetWidth(int width)"""
+        """SetWidth(self, int width)"""

         return _grid.GridCellFloatRenderer_SetWidth(*args, **kwargs)
 
     def GetPrecision(*args, **kwargs):
         return _grid.GridCellFloatRenderer_SetWidth(*args, **kwargs)
 
     def GetPrecision(*args, **kwargs):

-        """GetPrecision() -> int"""
+        """GetPrecision(self) -> int"""

         return _grid.GridCellFloatRenderer_GetPrecision(*args, **kwargs)
 
     def SetPrecision(*args, **kwargs):
         return _grid.GridCellFloatRenderer_GetPrecision(*args, **kwargs)
 
     def SetPrecision(*args, **kwargs):

-        """SetPrecision(int precision)"""
+        """SetPrecision(self, int precision)"""

         return _grid.GridCellFloatRenderer_SetPrecision(*args, **kwargs)
 
         return _grid.GridCellFloatRenderer_SetPrecision(*args, **kwargs)
 

-
-class GridCellFloatRendererPtr(GridCellFloatRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellFloatRenderer
-_grid.GridCellFloatRenderer_swigregister(GridCellFloatRendererPtr)
+GridCellFloatRenderer_swigregister = _grid.GridCellFloatRenderer_swigregister
+GridCellFloatRenderer_swigregister(GridCellFloatRenderer)

 
 class GridCellBoolRenderer(GridCellRenderer):
 
 class GridCellBoolRenderer(GridCellRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellBoolRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellBoolRenderer"""
-        newobj = _grid.new_GridCellBoolRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellBoolRenderer 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) -> GridCellBoolRenderer"""
+        _grid.GridCellBoolRenderer_swiginit(self,_grid.new_GridCellBoolRenderer(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-
-class GridCellBoolRendererPtr(GridCellBoolRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellBoolRenderer
-_grid.GridCellBoolRenderer_swigregister(GridCellBoolRendererPtr)
+GridCellBoolRenderer_swigregister = _grid.GridCellBoolRenderer_swigregister
+GridCellBoolRenderer_swigregister(GridCellBoolRenderer)

 
 class GridCellDateTimeRenderer(GridCellStringRenderer):
 
 class GridCellDateTimeRenderer(GridCellStringRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellDateTimeRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(String outformat=DateTimeFormatStr, String informat=DateTimeFormatStr) -> GridCellDateTimeRenderer"""
-        newobj = _grid.new_GridCellDateTimeRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellDateTimeRenderer 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 outformat=wxPyDefaultDateTimeFormat, String informat=wxPyDefaultDateTimeFormat) -> GridCellDateTimeRenderer"""
+        _grid.GridCellDateTimeRenderer_swiginit(self,_grid.new_GridCellDateTimeRenderer(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-
-class GridCellDateTimeRendererPtr(GridCellDateTimeRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellDateTimeRenderer
-_grid.GridCellDateTimeRenderer_swigregister(GridCellDateTimeRendererPtr)
+GridCellDateTimeRenderer_swigregister = _grid.GridCellDateTimeRenderer_swigregister
+GridCellDateTimeRenderer_swigregister(GridCellDateTimeRenderer)

 
 class GridCellEnumRenderer(GridCellStringRenderer):
 
 class GridCellEnumRenderer(GridCellStringRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellEnumRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(String choices=EmptyString) -> GridCellEnumRenderer"""
-        newobj = _grid.new_GridCellEnumRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellEnumRenderer 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 choices=EmptyString) -> GridCellEnumRenderer"""
+        _grid.GridCellEnumRenderer_swiginit(self,_grid.new_GridCellEnumRenderer(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-
-class GridCellEnumRendererPtr(GridCellEnumRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellEnumRenderer
-_grid.GridCellEnumRenderer_swigregister(GridCellEnumRendererPtr)
+GridCellEnumRenderer_swigregister = _grid.GridCellEnumRenderer_swigregister
+GridCellEnumRenderer_swigregister(GridCellEnumRenderer)

 
 class GridCellAutoWrapStringRenderer(GridCellStringRenderer):
 
 class GridCellAutoWrapStringRenderer(GridCellStringRenderer):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellAutoWrapStringRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellAutoWrapStringRenderer"""
-        newobj = _grid.new_GridCellAutoWrapStringRenderer(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellAutoWrapStringRenderer 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) -> GridCellAutoWrapStringRenderer"""
+        _grid.GridCellAutoWrapStringRenderer_swiginit(self,_grid.new_GridCellAutoWrapStringRenderer(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

+GridCellAutoWrapStringRenderer_swigregister = _grid.GridCellAutoWrapStringRenderer_swigregister
+GridCellAutoWrapStringRenderer_swigregister(GridCellAutoWrapStringRenderer)

 
 

-class GridCellAutoWrapStringRendererPtr(GridCellAutoWrapStringRenderer):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellAutoWrapStringRenderer
-_grid.GridCellAutoWrapStringRenderer_swigregister(GridCellAutoWrapStringRendererPtr)
-
-class GridCellEditor(object):
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def _setOORInfo(*args, **kwargs):
-        """_setOORInfo(PyObject _self)"""
-        return _grid.GridCellEditor__setOORInfo(*args, **kwargs)
-
+class GridCellEditor(GridCellWorker):
+    """Proxy of C++ GridCellEditor class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    def __init__(self): raise AttributeError, "No constructor defined"
+    __repr__ = _swig_repr

     def IsCreated(*args, **kwargs):
     def IsCreated(*args, **kwargs):

-        """IsCreated() -> bool"""
+        """IsCreated(self) -> bool"""

         return _grid.GridCellEditor_IsCreated(*args, **kwargs)
 
     def GetControl(*args, **kwargs):
         return _grid.GridCellEditor_IsCreated(*args, **kwargs)
 
     def GetControl(*args, **kwargs):

-        """GetControl() -> Control"""
+        """GetControl(self) -> Control"""

         return _grid.GridCellEditor_GetControl(*args, **kwargs)
 
     def SetControl(*args, **kwargs):
         return _grid.GridCellEditor_GetControl(*args, **kwargs)
 
     def SetControl(*args, **kwargs):

-        """SetControl(Control control)"""
+        """SetControl(self, Control control)"""

         return _grid.GridCellEditor_SetControl(*args, **kwargs)
 
     def GetCellAttr(*args, **kwargs):
         return _grid.GridCellEditor_SetControl(*args, **kwargs)
 
     def GetCellAttr(*args, **kwargs):

-        """GetCellAttr() -> GridCellAttr"""
+        """GetCellAttr(self) -> GridCellAttr"""

         return _grid.GridCellEditor_GetCellAttr(*args, **kwargs)
 
     def SetCellAttr(*args, **kwargs):
         return _grid.GridCellEditor_GetCellAttr(*args, **kwargs)
 
     def SetCellAttr(*args, **kwargs):

-        """SetCellAttr(GridCellAttr attr)"""
+        """SetCellAttr(self, GridCellAttr attr)"""

         return _grid.GridCellEditor_SetCellAttr(*args, **kwargs)
 
         return _grid.GridCellEditor_SetCellAttr(*args, **kwargs)
 

-    def SetParameters(*args, **kwargs):
-        """SetParameters(String params)"""
-        return _grid.GridCellEditor_SetParameters(*args, **kwargs)
-
-    def IncRef(*args, **kwargs):
-        """IncRef()"""
-        return _grid.GridCellEditor_IncRef(*args, **kwargs)
-
-    def DecRef(*args, **kwargs):
-        """DecRef()"""
-        return _grid.GridCellEditor_DecRef(*args, **kwargs)
-

     def Create(*args, **kwargs):
     def Create(*args, **kwargs):

-        """Create(Window parent, int id, EvtHandler evtHandler)"""
+        """Create(self, Window parent, int id, EvtHandler evtHandler)"""

         return _grid.GridCellEditor_Create(*args, **kwargs)
 
     def BeginEdit(*args, **kwargs):
         return _grid.GridCellEditor_Create(*args, **kwargs)
 
     def BeginEdit(*args, **kwargs):

-        """BeginEdit(int row, int col, Grid grid)"""
+        """BeginEdit(self, int row, int col, Grid grid)"""

         return _grid.GridCellEditor_BeginEdit(*args, **kwargs)
 
     def EndEdit(*args, **kwargs):
         return _grid.GridCellEditor_BeginEdit(*args, **kwargs)
 
     def EndEdit(*args, **kwargs):

-        """EndEdit(int row, int col, Grid grid) -> bool"""
+        """EndEdit(self, int row, int col, Grid grid) -> bool"""

         return _grid.GridCellEditor_EndEdit(*args, **kwargs)
 
     def Reset(*args, **kwargs):
         return _grid.GridCellEditor_EndEdit(*args, **kwargs)
 
     def Reset(*args, **kwargs):

-        """Reset()"""
+        """Reset(self)"""

         return _grid.GridCellEditor_Reset(*args, **kwargs)
 
     def Clone(*args, **kwargs):
         return _grid.GridCellEditor_Reset(*args, **kwargs)
 
     def Clone(*args, **kwargs):

-        """Clone() -> GridCellEditor"""
+        """Clone(self) -> GridCellEditor"""

         return _grid.GridCellEditor_Clone(*args, **kwargs)
 
     def SetSize(*args, **kwargs):
         return _grid.GridCellEditor_Clone(*args, **kwargs)
 
     def SetSize(*args, **kwargs):

-        """SetSize(Rect rect)"""
+        """SetSize(self, Rect rect)"""

         return _grid.GridCellEditor_SetSize(*args, **kwargs)
 
     def Show(*args, **kwargs):
         return _grid.GridCellEditor_SetSize(*args, **kwargs)
 
     def Show(*args, **kwargs):

-        """Show(bool show, GridCellAttr attr=None)"""
+        """Show(self, bool show, GridCellAttr attr=None)"""

         return _grid.GridCellEditor_Show(*args, **kwargs)
 
     def PaintBackground(*args, **kwargs):
         return _grid.GridCellEditor_Show(*args, **kwargs)
 
     def PaintBackground(*args, **kwargs):

-        """PaintBackground(Rect rectCell, GridCellAttr attr)"""
+        """PaintBackground(self, Rect rectCell, GridCellAttr attr)"""

         return _grid.GridCellEditor_PaintBackground(*args, **kwargs)
 
     def IsAcceptedKey(*args, **kwargs):
         return _grid.GridCellEditor_PaintBackground(*args, **kwargs)
 
     def IsAcceptedKey(*args, **kwargs):

-        """IsAcceptedKey(KeyEvent event) -> bool"""
+        """IsAcceptedKey(self, KeyEvent event) -> bool"""

         return _grid.GridCellEditor_IsAcceptedKey(*args, **kwargs)
 
     def StartingKey(*args, **kwargs):
         return _grid.GridCellEditor_IsAcceptedKey(*args, **kwargs)
 
     def StartingKey(*args, **kwargs):

-        """StartingKey(KeyEvent event)"""
+        """StartingKey(self, KeyEvent event)"""

         return _grid.GridCellEditor_StartingKey(*args, **kwargs)
 
     def StartingClick(*args, **kwargs):
         return _grid.GridCellEditor_StartingKey(*args, **kwargs)
 
     def StartingClick(*args, **kwargs):

-        """StartingClick()"""
+        """StartingClick(self)"""

         return _grid.GridCellEditor_StartingClick(*args, **kwargs)
 
     def HandleReturn(*args, **kwargs):
         return _grid.GridCellEditor_StartingClick(*args, **kwargs)
 
     def HandleReturn(*args, **kwargs):

-        """HandleReturn(KeyEvent event)"""
+        """HandleReturn(self, KeyEvent event)"""

         return _grid.GridCellEditor_HandleReturn(*args, **kwargs)
 
     def Destroy(*args, **kwargs):
         return _grid.GridCellEditor_HandleReturn(*args, **kwargs)
 
     def Destroy(*args, **kwargs):

-        """Destroy()"""
-        return _grid.GridCellEditor_Destroy(*args, **kwargs)
-
+        """Destroy(self)"""
+        val = _grid.GridCellEditor_Destroy(*args, **kwargs)
+        args[0].thisown = 0
+        return val

 
 

-class GridCellEditorPtr(GridCellEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellEditor
-_grid.GridCellEditor_swigregister(GridCellEditorPtr)
+GridCellEditor_swigregister = _grid.GridCellEditor_swigregister
+GridCellEditor_swigregister(GridCellEditor)

 
 class PyGridCellEditor(GridCellEditor):
 
 class PyGridCellEditor(GridCellEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxPyGridCellEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> PyGridCellEditor"""
-        newobj = _grid.new_PyGridCellEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ PyGridCellEditor 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) -> PyGridCellEditor"""
+        _grid.PyGridCellEditor_swiginit(self,_grid.new_PyGridCellEditor(*args, **kwargs))

         self._setCallbackInfo(self, PyGridCellEditor);self._setOORInfo(self)
 
     def _setCallbackInfo(*args, **kwargs):
         self._setCallbackInfo(self, PyGridCellEditor);self._setOORInfo(self)
 
     def _setCallbackInfo(*args, **kwargs):

-        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        """_setCallbackInfo(self, PyObject self, PyObject _class)"""

         return _grid.PyGridCellEditor__setCallbackInfo(*args, **kwargs)
 
         return _grid.PyGridCellEditor__setCallbackInfo(*args, **kwargs)
 

-    def base_SetSize(*args, **kwargs):
-        """base_SetSize(Rect rect)"""
-        return _grid.PyGridCellEditor_base_SetSize(*args, **kwargs)
-
-    def base_Show(*args, **kwargs):
-        """base_Show(bool show, GridCellAttr attr=None)"""
-        return _grid.PyGridCellEditor_base_Show(*args, **kwargs)
-
-    def base_PaintBackground(*args, **kwargs):
-        """base_PaintBackground(Rect rectCell, GridCellAttr attr)"""
-        return _grid.PyGridCellEditor_base_PaintBackground(*args, **kwargs)
-
-    def base_IsAcceptedKey(*args, **kwargs):
-        """base_IsAcceptedKey(KeyEvent event) -> bool"""
-        return _grid.PyGridCellEditor_base_IsAcceptedKey(*args, **kwargs)
-
-    def base_StartingKey(*args, **kwargs):
-        """base_StartingKey(KeyEvent event)"""
-        return _grid.PyGridCellEditor_base_StartingKey(*args, **kwargs)
-
-    def base_StartingClick(*args, **kwargs):
-        """base_StartingClick()"""
-        return _grid.PyGridCellEditor_base_StartingClick(*args, **kwargs)
-
-    def base_HandleReturn(*args, **kwargs):
-        """base_HandleReturn(KeyEvent event)"""
-        return _grid.PyGridCellEditor_base_HandleReturn(*args, **kwargs)
-
-    def base_Destroy(*args, **kwargs):
-        """base_Destroy()"""
-        return _grid.PyGridCellEditor_base_Destroy(*args, **kwargs)
-
-    def base_SetParameters(*args, **kwargs):
-        """base_SetParameters(String params)"""
-        return _grid.PyGridCellEditor_base_SetParameters(*args, **kwargs)
-
-
-class PyGridCellEditorPtr(PyGridCellEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = PyGridCellEditor
-_grid.PyGridCellEditor_swigregister(PyGridCellEditorPtr)
+    def SetParameters(*args, **kwargs):
+        """SetParameters(self, String params)"""
+        return _grid.PyGridCellEditor_SetParameters(*args, **kwargs)
+
+    def base_SetSize(*args, **kw):
+        return PyGridCellEditor.SetSize(*args, **kw)
+    base_SetSize = wx._deprecated(base_SetSize,
+                                   "Please use PyGridCellEditor.SetSize instead.")
+
+    def base_Show(*args, **kw):
+        return PyGridCellEditor.Show(*args, **kw)
+    base_Show = wx._deprecated(base_Show,
+                                   "Please use PyGridCellEditor.Show instead.")
+
+    def base_PaintBackground(*args, **kw):
+        return PyGridCellEditor.PaintBackground(*args, **kw)
+    base_PaintBackground = wx._deprecated(base_PaintBackground,
+                                   "Please use PyGridCellEditor.PaintBackground instead.")
+
+    def base_IsAcceptedKey(*args, **kw):
+        return PyGridCellEditor.IsAcceptedKey(*args, **kw)
+    base_IsAcceptedKey = wx._deprecated(base_IsAcceptedKey,
+                                   "Please use PyGridCellEditor.IsAcceptedKey instead.")
+
+    def base_StartingKey(*args, **kw):
+        return PyGridCellEditor.StartingKey(*args, **kw)
+    base_StartingKey = wx._deprecated(base_StartingKey,
+                                   "Please use PyGridCellEditor.StartingKey instead.")
+
+    def base_StartingClick(*args, **kw):
+        return PyGridCellEditor.StartingClick(*args, **kw)
+    base_StartingClick = wx._deprecated(base_StartingClick,
+                                   "Please use PyGridCellEditor.StartingClick instead.")
+
+    def base_HandleReturn(*args, **kw):
+        return PyGridCellEditor.HandleReturn(*args, **kw)
+    base_HandleReturn = wx._deprecated(base_HandleReturn,
+                                   "Please use PyGridCellEditor.HandleReturn instead.")
+
+    def base_Destroy(*args, **kw):
+        return PyGridCellEditor.Destroy(*args, **kw)
+    base_Destroy = wx._deprecated(base_Destroy,
+                                   "Please use PyGridCellEditor.Destroy instead.")
+
+    def base_SetParameters(*args, **kw):
+        return PyGridCellEditor.SetParameters(*args, **kw)
+    base_SetParameters = wx._deprecated(base_SetParameters,
+                                   "Please use PyGridCellEditor.SetParameters instead.")
+
+PyGridCellEditor_swigregister = _grid.PyGridCellEditor_swigregister
+PyGridCellEditor_swigregister(PyGridCellEditor)

 
 class GridCellTextEditor(GridCellEditor):
 
 class GridCellTextEditor(GridCellEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellTextEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellTextEditor"""
-        newobj = _grid.new_GridCellTextEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellTextEditor 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) -> GridCellTextEditor"""
+        _grid.GridCellTextEditor_swiginit(self,_grid.new_GridCellTextEditor(*args, **kwargs))

         self._setOORInfo(self)
 
     def GetValue(*args, **kwargs):
         self._setOORInfo(self)
 
     def GetValue(*args, **kwargs):

-        """GetValue() -> String"""
+        """GetValue(self) -> String"""

         return _grid.GridCellTextEditor_GetValue(*args, **kwargs)
 
         return _grid.GridCellTextEditor_GetValue(*args, **kwargs)
 

-
-class GridCellTextEditorPtr(GridCellTextEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellTextEditor
-_grid.GridCellTextEditor_swigregister(GridCellTextEditorPtr)
+GridCellTextEditor_swigregister = _grid.GridCellTextEditor_swigregister
+GridCellTextEditor_swigregister(GridCellTextEditor)

 
 class GridCellNumberEditor(GridCellTextEditor):
 
 class GridCellNumberEditor(GridCellTextEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellNumberEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(int min=-1, int max=-1) -> GridCellNumberEditor"""
-        newobj = _grid.new_GridCellNumberEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellNumberEditor 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, int min=-1, int max=-1) -> GridCellNumberEditor"""
+        _grid.GridCellNumberEditor_swiginit(self,_grid.new_GridCellNumberEditor(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-    def GetValue(*args, **kwargs):
-        """GetValue() -> String"""
-        return _grid.GridCellNumberEditor_GetValue(*args, **kwargs)
-
-
-class GridCellNumberEditorPtr(GridCellNumberEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellNumberEditor
-_grid.GridCellNumberEditor_swigregister(GridCellNumberEditorPtr)
+GridCellNumberEditor_swigregister = _grid.GridCellNumberEditor_swigregister
+GridCellNumberEditor_swigregister(GridCellNumberEditor)

 
 class GridCellFloatEditor(GridCellTextEditor):
 
 class GridCellFloatEditor(GridCellTextEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellFloatEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellFloatEditor"""
-        newobj = _grid.new_GridCellFloatEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellFloatEditor 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, int width=-1, int precision=-1) -> GridCellFloatEditor"""
+        _grid.GridCellFloatEditor_swiginit(self,_grid.new_GridCellFloatEditor(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-    def GetValue(*args, **kwargs):
-        """GetValue() -> String"""
-        return _grid.GridCellFloatEditor_GetValue(*args, **kwargs)
-
-
-class GridCellFloatEditorPtr(GridCellFloatEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellFloatEditor
-_grid.GridCellFloatEditor_swigregister(GridCellFloatEditorPtr)
+GridCellFloatEditor_swigregister = _grid.GridCellFloatEditor_swigregister
+GridCellFloatEditor_swigregister(GridCellFloatEditor)

 
 class GridCellBoolEditor(GridCellEditor):
 
 class GridCellBoolEditor(GridCellEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellBoolEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellBoolEditor"""
-        newobj = _grid.new_GridCellBoolEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellBoolEditor 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) -> GridCellBoolEditor"""
+        _grid.GridCellBoolEditor_swiginit(self,_grid.new_GridCellBoolEditor(*args, **kwargs))

         self._setOORInfo(self)
 
     def GetValue(*args, **kwargs):
         self._setOORInfo(self)
 
     def GetValue(*args, **kwargs):

-        """GetValue() -> String"""
+        """GetValue(self) -> String"""

         return _grid.GridCellBoolEditor_GetValue(*args, **kwargs)
 
         return _grid.GridCellBoolEditor_GetValue(*args, **kwargs)
 

-
-class GridCellBoolEditorPtr(GridCellBoolEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellBoolEditor
-_grid.GridCellBoolEditor_swigregister(GridCellBoolEditorPtr)
+GridCellBoolEditor_swigregister = _grid.GridCellBoolEditor_swigregister
+GridCellBoolEditor_swigregister(GridCellBoolEditor)

 
 class GridCellChoiceEditor(GridCellEditor):
 
 class GridCellChoiceEditor(GridCellEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellChoiceEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(int choices=0, String choices_array=None, bool allowOthers=False) -> GridCellChoiceEditor"""
-        newobj = _grid.new_GridCellChoiceEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellChoiceEditor 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, int choices=0, bool allowOthers=False) -> GridCellChoiceEditor"""
+        _grid.GridCellChoiceEditor_swiginit(self,_grid.new_GridCellChoiceEditor(*args, **kwargs))

         self._setOORInfo(self)
 
     def GetValue(*args, **kwargs):
         self._setOORInfo(self)
 
     def GetValue(*args, **kwargs):

-        """GetValue() -> String"""
+        """GetValue(self) -> String"""

         return _grid.GridCellChoiceEditor_GetValue(*args, **kwargs)
 
         return _grid.GridCellChoiceEditor_GetValue(*args, **kwargs)
 

-
-class GridCellChoiceEditorPtr(GridCellChoiceEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellChoiceEditor
-_grid.GridCellChoiceEditor_swigregister(GridCellChoiceEditorPtr)
+GridCellChoiceEditor_swigregister = _grid.GridCellChoiceEditor_swigregister
+GridCellChoiceEditor_swigregister(GridCellChoiceEditor)

 
 class GridCellEnumEditor(GridCellChoiceEditor):
 
 class GridCellEnumEditor(GridCellChoiceEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellEnumEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(String choices=EmptyString) -> GridCellEnumEditor"""
-        newobj = _grid.new_GridCellEnumEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellEnumEditor 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 choices=EmptyString) -> GridCellEnumEditor"""
+        _grid.GridCellEnumEditor_swiginit(self,_grid.new_GridCellEnumEditor(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-    def GetValue(*args, **kwargs):
-        """GetValue() -> String"""
-        return _grid.GridCellEnumEditor_GetValue(*args, **kwargs)
-
-
-class GridCellEnumEditorPtr(GridCellEnumEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellEnumEditor
-_grid.GridCellEnumEditor_swigregister(GridCellEnumEditorPtr)
+GridCellEnumEditor_swigregister = _grid.GridCellEnumEditor_swigregister
+GridCellEnumEditor_swigregister(GridCellEnumEditor)

 
 class GridCellAutoWrapStringEditor(GridCellTextEditor):
 
 class GridCellAutoWrapStringEditor(GridCellTextEditor):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellAutoWrapStringEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellAutoWrapStringEditor"""
-        newobj = _grid.new_GridCellAutoWrapStringEditor(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellAutoWrapStringEditor 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) -> GridCellAutoWrapStringEditor"""
+        _grid.GridCellAutoWrapStringEditor_swiginit(self,_grid.new_GridCellAutoWrapStringEditor(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-    def GetValue(*args, **kwargs):
-        """GetValue() -> String"""
-        return _grid.GridCellAutoWrapStringEditor_GetValue(*args, **kwargs)
-
-
-class GridCellAutoWrapStringEditorPtr(GridCellAutoWrapStringEditor):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellAutoWrapStringEditor
-_grid.GridCellAutoWrapStringEditor_swigregister(GridCellAutoWrapStringEditorPtr)
+GridCellAutoWrapStringEditor_swigregister = _grid.GridCellAutoWrapStringEditor_swigregister
+GridCellAutoWrapStringEditor_swigregister(GridCellAutoWrapStringEditor)

 
 class GridCellAttr(object):
 
 class GridCellAttr(object):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellAttr instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    """Proxy of C++ GridCellAttr class"""
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr

     Any = _grid.GridCellAttr_Any
     Default = _grid.GridCellAttr_Default
     Cell = _grid.GridCellAttr_Cell
     Any = _grid.GridCellAttr_Any
     Default = _grid.GridCellAttr_Default
     Cell = _grid.GridCellAttr_Cell


@@ -568,115 +494,114 @@ class GridCellAttr(object):
     Col = _grid.GridCellAttr_Col
     Merged = _grid.GridCellAttr_Merged
     def _setOORInfo(*args, **kwargs):
     Col = _grid.GridCellAttr_Col
     Merged = _grid.GridCellAttr_Merged
     def _setOORInfo(*args, **kwargs):

-        """_setOORInfo(PyObject _self)"""
+        """_setOORInfo(self, PyObject _self)"""

         return _grid.GridCellAttr__setOORInfo(*args, **kwargs)
 
         return _grid.GridCellAttr__setOORInfo(*args, **kwargs)
 

-    def __init__(self, *args, **kwargs):
-        """__init__(GridCellAttr attrDefault=None) -> GridCellAttr"""
-        newobj = _grid.new_GridCellAttr(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    def __init__(self, *args, **kwargs): 
+        """__init__(self, GridCellAttr attrDefault=None) -> GridCellAttr"""
+        _grid.GridCellAttr_swiginit(self,_grid.new_GridCellAttr(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

+    __swig_destroy__ = _grid.delete_GridCellAttr
+    __del__ = lambda self : None;

     def Clone(*args, **kwargs):
     def Clone(*args, **kwargs):

-        """Clone() -> GridCellAttr"""
+        """Clone(self) -> GridCellAttr"""

         return _grid.GridCellAttr_Clone(*args, **kwargs)
 
     def MergeWith(*args, **kwargs):
         return _grid.GridCellAttr_Clone(*args, **kwargs)
 
     def MergeWith(*args, **kwargs):

-        """MergeWith(GridCellAttr mergefrom)"""
+        """MergeWith(self, GridCellAttr mergefrom)"""

         return _grid.GridCellAttr_MergeWith(*args, **kwargs)
 
     def IncRef(*args, **kwargs):
         return _grid.GridCellAttr_MergeWith(*args, **kwargs)
 
     def IncRef(*args, **kwargs):

-        """IncRef()"""
+        """IncRef(self)"""

         return _grid.GridCellAttr_IncRef(*args, **kwargs)
 
     def DecRef(*args, **kwargs):
         return _grid.GridCellAttr_IncRef(*args, **kwargs)
 
     def DecRef(*args, **kwargs):

-        """DecRef()"""
+        """DecRef(self)"""

         return _grid.GridCellAttr_DecRef(*args, **kwargs)
 
     def SetTextColour(*args, **kwargs):
         return _grid.GridCellAttr_DecRef(*args, **kwargs)
 
     def SetTextColour(*args, **kwargs):

-        """SetTextColour(Colour colText)"""
+        """SetTextColour(self, Colour colText)"""

         return _grid.GridCellAttr_SetTextColour(*args, **kwargs)
 
     def SetBackgroundColour(*args, **kwargs):
         return _grid.GridCellAttr_SetTextColour(*args, **kwargs)
 
     def SetBackgroundColour(*args, **kwargs):

-        """SetBackgroundColour(Colour colBack)"""
+        """SetBackgroundColour(self, Colour colBack)"""

         return _grid.GridCellAttr_SetBackgroundColour(*args, **kwargs)
 
     def SetFont(*args, **kwargs):
         return _grid.GridCellAttr_SetBackgroundColour(*args, **kwargs)
 
     def SetFont(*args, **kwargs):

-        """SetFont(Font font)"""
+        """SetFont(self, Font font)"""

         return _grid.GridCellAttr_SetFont(*args, **kwargs)
 
     def SetAlignment(*args, **kwargs):
         return _grid.GridCellAttr_SetFont(*args, **kwargs)
 
     def SetAlignment(*args, **kwargs):

-        """SetAlignment(int hAlign, int vAlign)"""
+        """SetAlignment(self, int hAlign, int vAlign)"""

         return _grid.GridCellAttr_SetAlignment(*args, **kwargs)
 
     def SetSize(*args, **kwargs):
         return _grid.GridCellAttr_SetAlignment(*args, **kwargs)
 
     def SetSize(*args, **kwargs):

-        """SetSize(int num_rows, int num_cols)"""
+        """SetSize(self, int num_rows, int num_cols)"""

         return _grid.GridCellAttr_SetSize(*args, **kwargs)
 
     def SetOverflow(*args, **kwargs):
         return _grid.GridCellAttr_SetSize(*args, **kwargs)
 
     def SetOverflow(*args, **kwargs):

-        """SetOverflow(bool allow=True)"""
+        """SetOverflow(self, bool allow=True)"""

         return _grid.GridCellAttr_SetOverflow(*args, **kwargs)
 
     def SetReadOnly(*args, **kwargs):
         return _grid.GridCellAttr_SetOverflow(*args, **kwargs)
 
     def SetReadOnly(*args, **kwargs):

-        """SetReadOnly(bool isReadOnly=True)"""
+        """SetReadOnly(self, bool isReadOnly=True)"""

         return _grid.GridCellAttr_SetReadOnly(*args, **kwargs)
 
     def SetRenderer(*args, **kwargs):
         return _grid.GridCellAttr_SetReadOnly(*args, **kwargs)
 
     def SetRenderer(*args, **kwargs):

-        """SetRenderer(GridCellRenderer renderer)"""
+        """SetRenderer(self, GridCellRenderer renderer)"""

         return _grid.GridCellAttr_SetRenderer(*args, **kwargs)
 
     def SetEditor(*args, **kwargs):
         return _grid.GridCellAttr_SetRenderer(*args, **kwargs)
 
     def SetEditor(*args, **kwargs):

-        """SetEditor(GridCellEditor editor)"""
+        """SetEditor(self, GridCellEditor editor)"""

         return _grid.GridCellAttr_SetEditor(*args, **kwargs)
 
     def SetKind(*args, **kwargs):
         return _grid.GridCellAttr_SetEditor(*args, **kwargs)
 
     def SetKind(*args, **kwargs):

-        """SetKind(int kind)"""
+        """SetKind(self, int kind)"""

         return _grid.GridCellAttr_SetKind(*args, **kwargs)
 
     def HasTextColour(*args, **kwargs):
         return _grid.GridCellAttr_SetKind(*args, **kwargs)
 
     def HasTextColour(*args, **kwargs):

-        """HasTextColour() -> bool"""
+        """HasTextColour(self) -> bool"""

         return _grid.GridCellAttr_HasTextColour(*args, **kwargs)
 
     def HasBackgroundColour(*args, **kwargs):
         return _grid.GridCellAttr_HasTextColour(*args, **kwargs)
 
     def HasBackgroundColour(*args, **kwargs):

-        """HasBackgroundColour() -> bool"""
+        """HasBackgroundColour(self) -> bool"""

         return _grid.GridCellAttr_HasBackgroundColour(*args, **kwargs)
 
     def HasFont(*args, **kwargs):
         return _grid.GridCellAttr_HasBackgroundColour(*args, **kwargs)
 
     def HasFont(*args, **kwargs):

-        """HasFont() -> bool"""
+        """HasFont(self) -> bool"""

         return _grid.GridCellAttr_HasFont(*args, **kwargs)
 
     def HasAlignment(*args, **kwargs):
         return _grid.GridCellAttr_HasFont(*args, **kwargs)
 
     def HasAlignment(*args, **kwargs):

-        """HasAlignment() -> bool"""
+        """HasAlignment(self) -> bool"""

         return _grid.GridCellAttr_HasAlignment(*args, **kwargs)
 
     def HasRenderer(*args, **kwargs):
         return _grid.GridCellAttr_HasAlignment(*args, **kwargs)
 
     def HasRenderer(*args, **kwargs):

-        """HasRenderer() -> bool"""
+        """HasRenderer(self) -> bool"""

         return _grid.GridCellAttr_HasRenderer(*args, **kwargs)
 
     def HasEditor(*args, **kwargs):
         return _grid.GridCellAttr_HasRenderer(*args, **kwargs)
 
     def HasEditor(*args, **kwargs):

-        """HasEditor() -> bool"""
+        """HasEditor(self) -> bool"""

         return _grid.GridCellAttr_HasEditor(*args, **kwargs)
 
     def HasReadWriteMode(*args, **kwargs):
         return _grid.GridCellAttr_HasEditor(*args, **kwargs)
 
     def HasReadWriteMode(*args, **kwargs):

-        """HasReadWriteMode() -> bool"""
+        """HasReadWriteMode(self) -> bool"""

         return _grid.GridCellAttr_HasReadWriteMode(*args, **kwargs)
 
     def HasOverflowMode(*args, **kwargs):
         return _grid.GridCellAttr_HasReadWriteMode(*args, **kwargs)
 
     def HasOverflowMode(*args, **kwargs):

-        """HasOverflowMode() -> bool"""
+        """HasOverflowMode(self) -> bool"""

         return _grid.GridCellAttr_HasOverflowMode(*args, **kwargs)
 
     def GetTextColour(*args, **kwargs):
         return _grid.GridCellAttr_HasOverflowMode(*args, **kwargs)
 
     def GetTextColour(*args, **kwargs):

-        """GetTextColour() -> Colour"""
+        """GetTextColour(self) -> Colour"""

         return _grid.GridCellAttr_GetTextColour(*args, **kwargs)
 
     def GetBackgroundColour(*args, **kwargs):
         return _grid.GridCellAttr_GetTextColour(*args, **kwargs)
 
     def GetBackgroundColour(*args, **kwargs):

-        """GetBackgroundColour() -> Colour"""
+        """GetBackgroundColour(self) -> Colour"""

         return _grid.GridCellAttr_GetBackgroundColour(*args, **kwargs)
 
     def GetFont(*args, **kwargs):
         return _grid.GridCellAttr_GetBackgroundColour(*args, **kwargs)
 
     def GetFont(*args, **kwargs):

-        """GetFont() -> Font"""
+        """GetFont(self) -> Font"""

         return _grid.GridCellAttr_GetFont(*args, **kwargs)
 
     def GetAlignment(*args, **kwargs):
         return _grid.GridCellAttr_GetFont(*args, **kwargs)
 
     def GetAlignment(*args, **kwargs):


@@ -688,396 +613,406 @@ class GridCellAttr(object):
         return _grid.GridCellAttr_GetSize(*args, **kwargs)
 
     def GetOverflow(*args, **kwargs):
         return _grid.GridCellAttr_GetSize(*args, **kwargs)
 
     def GetOverflow(*args, **kwargs):

-        """GetOverflow() -> bool"""
+        """GetOverflow(self) -> bool"""

         return _grid.GridCellAttr_GetOverflow(*args, **kwargs)
 
     def GetRenderer(*args, **kwargs):
         return _grid.GridCellAttr_GetOverflow(*args, **kwargs)
 
     def GetRenderer(*args, **kwargs):

-        """GetRenderer(Grid grid, int row, int col) -> GridCellRenderer"""
+        """GetRenderer(self, Grid grid, int row, int col) -> GridCellRenderer"""

         return _grid.GridCellAttr_GetRenderer(*args, **kwargs)
 
     def GetEditor(*args, **kwargs):
         return _grid.GridCellAttr_GetRenderer(*args, **kwargs)
 
     def GetEditor(*args, **kwargs):

-        """GetEditor(Grid grid, int row, int col) -> GridCellEditor"""
+        """GetEditor(self, Grid grid, int row, int col) -> GridCellEditor"""

         return _grid.GridCellAttr_GetEditor(*args, **kwargs)
 
     def IsReadOnly(*args, **kwargs):
         return _grid.GridCellAttr_GetEditor(*args, **kwargs)
 
     def IsReadOnly(*args, **kwargs):

-        """IsReadOnly() -> bool"""
+        """IsReadOnly(self) -> bool"""

         return _grid.GridCellAttr_IsReadOnly(*args, **kwargs)
 
         return _grid.GridCellAttr_IsReadOnly(*args, **kwargs)
 

+    def GetKind(*args, **kwargs):
+        """GetKind(self) -> int"""
+        return _grid.GridCellAttr_GetKind(*args, **kwargs)
+

     def SetDefAttr(*args, **kwargs):
     def SetDefAttr(*args, **kwargs):

-        """SetDefAttr(GridCellAttr defAttr)"""
+        """SetDefAttr(self, GridCellAttr defAttr)"""

         return _grid.GridCellAttr_SetDefAttr(*args, **kwargs)
 
         return _grid.GridCellAttr_SetDefAttr(*args, **kwargs)
 

-
-class GridCellAttrPtr(GridCellAttr):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellAttr
-_grid.GridCellAttr_swigregister(GridCellAttrPtr)
+GridCellAttr_swigregister = _grid.GridCellAttr_swigregister
+GridCellAttr_swigregister(GridCellAttr)

 
 class GridCellAttrProvider(object):
 
 class GridCellAttrProvider(object):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellAttrProvider instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> GridCellAttrProvider"""
-        newobj = _grid.new_GridCellAttrProvider(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridCellAttrProvider 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) -> GridCellAttrProvider"""
+        _grid.GridCellAttrProvider_swiginit(self,_grid.new_GridCellAttrProvider(*args, **kwargs))

         self._setOORInfo(self)
 
     def _setOORInfo(*args, **kwargs):
         self._setOORInfo(self)
 
     def _setOORInfo(*args, **kwargs):

-        """_setOORInfo(PyObject _self)"""
+        """_setOORInfo(self, PyObject _self)"""

         return _grid.GridCellAttrProvider__setOORInfo(*args, **kwargs)
 
     def GetAttr(*args, **kwargs):
         return _grid.GridCellAttrProvider__setOORInfo(*args, **kwargs)
 
     def GetAttr(*args, **kwargs):

-        """GetAttr(int row, int col, int kind) -> GridCellAttr"""
+        """GetAttr(self, int row, int col, int kind) -> GridCellAttr"""

         return _grid.GridCellAttrProvider_GetAttr(*args, **kwargs)
 
     def SetAttr(*args, **kwargs):
         return _grid.GridCellAttrProvider_GetAttr(*args, **kwargs)
 
     def SetAttr(*args, **kwargs):

-        """SetAttr(GridCellAttr attr, int row, int col)"""
+        """SetAttr(self, GridCellAttr attr, int row, int col)"""

         return _grid.GridCellAttrProvider_SetAttr(*args, **kwargs)
 
     def SetRowAttr(*args, **kwargs):
         return _grid.GridCellAttrProvider_SetAttr(*args, **kwargs)
 
     def SetRowAttr(*args, **kwargs):

-        """SetRowAttr(GridCellAttr attr, int row)"""
+        """SetRowAttr(self, GridCellAttr attr, int row)"""

         return _grid.GridCellAttrProvider_SetRowAttr(*args, **kwargs)
 
     def SetColAttr(*args, **kwargs):
         return _grid.GridCellAttrProvider_SetRowAttr(*args, **kwargs)
 
     def SetColAttr(*args, **kwargs):

-        """SetColAttr(GridCellAttr attr, int col)"""
+        """SetColAttr(self, GridCellAttr attr, int col)"""

         return _grid.GridCellAttrProvider_SetColAttr(*args, **kwargs)
 
     def UpdateAttrRows(*args, **kwargs):
         return _grid.GridCellAttrProvider_SetColAttr(*args, **kwargs)
 
     def UpdateAttrRows(*args, **kwargs):

-        """UpdateAttrRows(size_t pos, int numRows)"""
+        """UpdateAttrRows(self, size_t pos, int numRows)"""

         return _grid.GridCellAttrProvider_UpdateAttrRows(*args, **kwargs)
 
     def UpdateAttrCols(*args, **kwargs):
         return _grid.GridCellAttrProvider_UpdateAttrRows(*args, **kwargs)
 
     def UpdateAttrCols(*args, **kwargs):

-        """UpdateAttrCols(size_t pos, int numCols)"""
+        """UpdateAttrCols(self, size_t pos, int numCols)"""

         return _grid.GridCellAttrProvider_UpdateAttrCols(*args, **kwargs)
 
         return _grid.GridCellAttrProvider_UpdateAttrCols(*args, **kwargs)
 

-
-class GridCellAttrProviderPtr(GridCellAttrProvider):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellAttrProvider
-_grid.GridCellAttrProvider_swigregister(GridCellAttrProviderPtr)
+GridCellAttrProvider_swigregister = _grid.GridCellAttrProvider_swigregister
+GridCellAttrProvider_swigregister(GridCellAttrProvider)

 
 class PyGridCellAttrProvider(GridCellAttrProvider):
 
 class PyGridCellAttrProvider(GridCellAttrProvider):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxPyGridCellAttrProvider instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> PyGridCellAttrProvider"""
-        newobj = _grid.new_PyGridCellAttrProvider(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ PyGridCellAttrProvider 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) -> PyGridCellAttrProvider"""
+        _grid.PyGridCellAttrProvider_swiginit(self,_grid.new_PyGridCellAttrProvider(*args, **kwargs))

         self._setCallbackInfo(self, PyGridCellAttrProvider)
 
     def _setCallbackInfo(*args, **kwargs):
         self._setCallbackInfo(self, PyGridCellAttrProvider)
 
     def _setCallbackInfo(*args, **kwargs):

-        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        """_setCallbackInfo(self, PyObject self, PyObject _class)"""

         return _grid.PyGridCellAttrProvider__setCallbackInfo(*args, **kwargs)
 
         return _grid.PyGridCellAttrProvider__setCallbackInfo(*args, **kwargs)
 

-    def base_GetAttr(*args, **kwargs):
-        """base_GetAttr(int row, int col, int kind) -> GridCellAttr"""
-        return _grid.PyGridCellAttrProvider_base_GetAttr(*args, **kwargs)
-
-    def base_SetAttr(*args, **kwargs):
-        """base_SetAttr(GridCellAttr attr, int row, int col)"""
-        return _grid.PyGridCellAttrProvider_base_SetAttr(*args, **kwargs)
-
-    def base_SetRowAttr(*args, **kwargs):
-        """base_SetRowAttr(GridCellAttr attr, int row)"""
-        return _grid.PyGridCellAttrProvider_base_SetRowAttr(*args, **kwargs)
-
-    def base_SetColAttr(*args, **kwargs):
-        """base_SetColAttr(GridCellAttr attr, int col)"""
-        return _grid.PyGridCellAttrProvider_base_SetColAttr(*args, **kwargs)
+    def GetAttr(*args, **kwargs):
+        """GetAttr(self, int row, int col, int kind) -> GridCellAttr"""
+        return _grid.PyGridCellAttrProvider_GetAttr(*args, **kwargs)

 
 

+    def SetAttr(*args, **kwargs):
+        """SetAttr(self, GridCellAttr attr, int row, int col)"""
+        return _grid.PyGridCellAttrProvider_SetAttr(*args, **kwargs)

 
 

-class PyGridCellAttrProviderPtr(PyGridCellAttrProvider):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = PyGridCellAttrProvider
-_grid.PyGridCellAttrProvider_swigregister(PyGridCellAttrProviderPtr)
+    def SetRowAttr(*args, **kwargs):
+        """SetRowAttr(self, GridCellAttr attr, int row)"""
+        return _grid.PyGridCellAttrProvider_SetRowAttr(*args, **kwargs)

 
 

-class GridTableBase(core.Object):
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridTableBase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+    def SetColAttr(*args, **kwargs):
+        """SetColAttr(self, GridCellAttr attr, int col)"""
+        return _grid.PyGridCellAttrProvider_SetColAttr(*args, **kwargs)
+
+    def base_GetAttr(*args, **kw):
+        return PyGridCellAttrProvider.GetAttr(*args, **kw)
+    base_GetAttr = wx._deprecated(base_GetAttr,
+                                   "Please use PyGridCellAttrProvider.GetAttr instead.")
+
+    def base_SetAttr(*args, **kw):
+        return PyGridCellAttrProvider.SetAttr(*args, **kw)
+    base_SetAttr = wx._deprecated(base_SetAttr,
+                                   "Please use PyGridCellAttrProvider.SetAttr instead.")
+
+    def base_SetRowAttr(*args, **kw):
+        return PyGridCellAttrProvider.SetRowAttr(*args, **kw)
+    base_SetRowAttr = wx._deprecated(base_SetRowAttr,
+                                   "Please use PyGridCellAttrProvider.SetRowAttr instead.")
+
+    def base_SetColAttr(*args, **kw):
+        return PyGridCellAttrProvider.SetColAttr(*args, **kw)
+    base_SetColAttr = wx._deprecated(base_SetColAttr,
+                                   "Please use PyGridCellAttrProvider.SetColAttr instead.")
+
+PyGridCellAttrProvider_swigregister = _grid.PyGridCellAttrProvider_swigregister
+PyGridCellAttrProvider_swigregister(PyGridCellAttrProvider)
+
+class GridTableBase(_core.Object):
+    """Proxy of C++ GridTableBase 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__ = _grid.delete_GridTableBase
+    __del__ = lambda self : None;

     def _setOORInfo(*args, **kwargs):
     def _setOORInfo(*args, **kwargs):

-        """_setOORInfo(PyObject _self)"""
+        """_setOORInfo(self, PyObject _self)"""

         return _grid.GridTableBase__setOORInfo(*args, **kwargs)
 
     def SetAttrProvider(*args, **kwargs):
         return _grid.GridTableBase__setOORInfo(*args, **kwargs)
 
     def SetAttrProvider(*args, **kwargs):

-        """SetAttrProvider(GridCellAttrProvider attrProvider)"""
+        """SetAttrProvider(self, GridCellAttrProvider attrProvider)"""

         return _grid.GridTableBase_SetAttrProvider(*args, **kwargs)
 
     def GetAttrProvider(*args, **kwargs):
         return _grid.GridTableBase_SetAttrProvider(*args, **kwargs)
 
     def GetAttrProvider(*args, **kwargs):

-        """GetAttrProvider() -> GridCellAttrProvider"""
+        """GetAttrProvider(self) -> GridCellAttrProvider"""

         return _grid.GridTableBase_GetAttrProvider(*args, **kwargs)
 
     def SetView(*args, **kwargs):
         return _grid.GridTableBase_GetAttrProvider(*args, **kwargs)
 
     def SetView(*args, **kwargs):

-        """SetView(Grid grid)"""
+        """SetView(self, Grid grid)"""

         return _grid.GridTableBase_SetView(*args, **kwargs)
 
     def GetView(*args, **kwargs):
         return _grid.GridTableBase_SetView(*args, **kwargs)
 
     def GetView(*args, **kwargs):

-        """GetView() -> Grid"""
+        """GetView(self) -> Grid"""

         return _grid.GridTableBase_GetView(*args, **kwargs)
 
     def GetNumberRows(*args, **kwargs):
         return _grid.GridTableBase_GetView(*args, **kwargs)
 
     def GetNumberRows(*args, **kwargs):

-        """GetNumberRows() -> int"""
+        """GetNumberRows(self) -> int"""

         return _grid.GridTableBase_GetNumberRows(*args, **kwargs)
 
     def GetNumberCols(*args, **kwargs):
         return _grid.GridTableBase_GetNumberRows(*args, **kwargs)
 
     def GetNumberCols(*args, **kwargs):

-        """GetNumberCols() -> int"""
+        """GetNumberCols(self) -> int"""

         return _grid.GridTableBase_GetNumberCols(*args, **kwargs)
 
     def IsEmptyCell(*args, **kwargs):
         return _grid.GridTableBase_GetNumberCols(*args, **kwargs)
 
     def IsEmptyCell(*args, **kwargs):

-        """IsEmptyCell(int row, int col) -> bool"""
+        """IsEmptyCell(self, int row, int col) -> bool"""

         return _grid.GridTableBase_IsEmptyCell(*args, **kwargs)
 
     def GetValue(*args, **kwargs):
         return _grid.GridTableBase_IsEmptyCell(*args, **kwargs)
 
     def GetValue(*args, **kwargs):

-        """GetValue(int row, int col) -> String"""
+        """GetValue(self, int row, int col) -> String"""

         return _grid.GridTableBase_GetValue(*args, **kwargs)
 
     def SetValue(*args, **kwargs):
         return _grid.GridTableBase_GetValue(*args, **kwargs)
 
     def SetValue(*args, **kwargs):

-        """SetValue(int row, int col, String value)"""
+        """SetValue(self, int row, int col, String value)"""

         return _grid.GridTableBase_SetValue(*args, **kwargs)
 
     def GetTypeName(*args, **kwargs):
         return _grid.GridTableBase_SetValue(*args, **kwargs)
 
     def GetTypeName(*args, **kwargs):

-        """GetTypeName(int row, int col) -> String"""
+        """GetTypeName(self, int row, int col) -> String"""

         return _grid.GridTableBase_GetTypeName(*args, **kwargs)
 
     def CanGetValueAs(*args, **kwargs):
         return _grid.GridTableBase_GetTypeName(*args, **kwargs)
 
     def CanGetValueAs(*args, **kwargs):

-        """CanGetValueAs(int row, int col, String typeName) -> bool"""
+        """CanGetValueAs(self, int row, int col, String typeName) -> bool"""

         return _grid.GridTableBase_CanGetValueAs(*args, **kwargs)
 
     def CanSetValueAs(*args, **kwargs):
         return _grid.GridTableBase_CanGetValueAs(*args, **kwargs)
 
     def CanSetValueAs(*args, **kwargs):

-        """CanSetValueAs(int row, int col, String typeName) -> bool"""
+        """CanSetValueAs(self, int row, int col, String typeName) -> bool"""

         return _grid.GridTableBase_CanSetValueAs(*args, **kwargs)
 
     def GetValueAsLong(*args, **kwargs):
         return _grid.GridTableBase_CanSetValueAs(*args, **kwargs)
 
     def GetValueAsLong(*args, **kwargs):

-        """GetValueAsLong(int row, int col) -> long"""
+        """GetValueAsLong(self, int row, int col) -> long"""

         return _grid.GridTableBase_GetValueAsLong(*args, **kwargs)
 
     def GetValueAsDouble(*args, **kwargs):
         return _grid.GridTableBase_GetValueAsLong(*args, **kwargs)
 
     def GetValueAsDouble(*args, **kwargs):

-        """GetValueAsDouble(int row, int col) -> double"""
+        """GetValueAsDouble(self, int row, int col) -> double"""

         return _grid.GridTableBase_GetValueAsDouble(*args, **kwargs)
 
     def GetValueAsBool(*args, **kwargs):
         return _grid.GridTableBase_GetValueAsDouble(*args, **kwargs)
 
     def GetValueAsBool(*args, **kwargs):

-        """GetValueAsBool(int row, int col) -> bool"""
+        """GetValueAsBool(self, int row, int col) -> bool"""

         return _grid.GridTableBase_GetValueAsBool(*args, **kwargs)
 
     def SetValueAsLong(*args, **kwargs):
         return _grid.GridTableBase_GetValueAsBool(*args, **kwargs)
 
     def SetValueAsLong(*args, **kwargs):

-        """SetValueAsLong(int row, int col, long value)"""
+        """SetValueAsLong(self, int row, int col, long value)"""

         return _grid.GridTableBase_SetValueAsLong(*args, **kwargs)
 
     def SetValueAsDouble(*args, **kwargs):
         return _grid.GridTableBase_SetValueAsLong(*args, **kwargs)
 
     def SetValueAsDouble(*args, **kwargs):

-        """SetValueAsDouble(int row, int col, double value)"""
+        """SetValueAsDouble(self, int row, int col, double value)"""

         return _grid.GridTableBase_SetValueAsDouble(*args, **kwargs)
 
     def SetValueAsBool(*args, **kwargs):
         return _grid.GridTableBase_SetValueAsDouble(*args, **kwargs)
 
     def SetValueAsBool(*args, **kwargs):

-        """SetValueAsBool(int row, int col, bool value)"""
+        """SetValueAsBool(self, int row, int col, bool value)"""

         return _grid.GridTableBase_SetValueAsBool(*args, **kwargs)
 
     def Clear(*args, **kwargs):
         return _grid.GridTableBase_SetValueAsBool(*args, **kwargs)
 
     def Clear(*args, **kwargs):

-        """Clear()"""
+        """Clear(self)"""

         return _grid.GridTableBase_Clear(*args, **kwargs)
 
     def InsertRows(*args, **kwargs):
         return _grid.GridTableBase_Clear(*args, **kwargs)
 
     def InsertRows(*args, **kwargs):

-        """InsertRows(size_t pos=0, size_t numRows=1) -> bool"""
+        """InsertRows(self, size_t pos=0, size_t numRows=1) -> bool"""

         return _grid.GridTableBase_InsertRows(*args, **kwargs)
 
     def AppendRows(*args, **kwargs):
         return _grid.GridTableBase_InsertRows(*args, **kwargs)
 
     def AppendRows(*args, **kwargs):

-        """AppendRows(size_t numRows=1) -> bool"""
+        """AppendRows(self, size_t numRows=1) -> bool"""

         return _grid.GridTableBase_AppendRows(*args, **kwargs)
 
     def DeleteRows(*args, **kwargs):
         return _grid.GridTableBase_AppendRows(*args, **kwargs)
 
     def DeleteRows(*args, **kwargs):

-        """DeleteRows(size_t pos=0, size_t numRows=1) -> bool"""
+        """DeleteRows(self, size_t pos=0, size_t numRows=1) -> bool"""

         return _grid.GridTableBase_DeleteRows(*args, **kwargs)
 
     def InsertCols(*args, **kwargs):
         return _grid.GridTableBase_DeleteRows(*args, **kwargs)
 
     def InsertCols(*args, **kwargs):

-        """InsertCols(size_t pos=0, size_t numCols=1) -> bool"""
+        """InsertCols(self, size_t pos=0, size_t numCols=1) -> bool"""

         return _grid.GridTableBase_InsertCols(*args, **kwargs)
 
     def AppendCols(*args, **kwargs):
         return _grid.GridTableBase_InsertCols(*args, **kwargs)
 
     def AppendCols(*args, **kwargs):

-        """AppendCols(size_t numCols=1) -> bool"""
+        """AppendCols(self, size_t numCols=1) -> bool"""

         return _grid.GridTableBase_AppendCols(*args, **kwargs)
 
     def DeleteCols(*args, **kwargs):
         return _grid.GridTableBase_AppendCols(*args, **kwargs)
 
     def DeleteCols(*args, **kwargs):

-        """DeleteCols(size_t pos=0, size_t numCols=1) -> bool"""
+        """DeleteCols(self, size_t pos=0, size_t numCols=1) -> bool"""

         return _grid.GridTableBase_DeleteCols(*args, **kwargs)
 
     def GetRowLabelValue(*args, **kwargs):
         return _grid.GridTableBase_DeleteCols(*args, **kwargs)
 
     def GetRowLabelValue(*args, **kwargs):

-        """GetRowLabelValue(int row) -> String"""
+        """GetRowLabelValue(self, int row) -> String"""

         return _grid.GridTableBase_GetRowLabelValue(*args, **kwargs)
 
     def GetColLabelValue(*args, **kwargs):
         return _grid.GridTableBase_GetRowLabelValue(*args, **kwargs)
 
     def GetColLabelValue(*args, **kwargs):

-        """GetColLabelValue(int col) -> String"""
+        """GetColLabelValue(self, int col) -> String"""

         return _grid.GridTableBase_GetColLabelValue(*args, **kwargs)
 
     def SetRowLabelValue(*args, **kwargs):
         return _grid.GridTableBase_GetColLabelValue(*args, **kwargs)
 
     def SetRowLabelValue(*args, **kwargs):

-        """SetRowLabelValue(int row, String value)"""
+        """SetRowLabelValue(self, int row, String value)"""

         return _grid.GridTableBase_SetRowLabelValue(*args, **kwargs)
 
     def SetColLabelValue(*args, **kwargs):
         return _grid.GridTableBase_SetRowLabelValue(*args, **kwargs)
 
     def SetColLabelValue(*args, **kwargs):

-        """SetColLabelValue(int col, String value)"""
+        """SetColLabelValue(self, int col, String value)"""

         return _grid.GridTableBase_SetColLabelValue(*args, **kwargs)
 
     def CanHaveAttributes(*args, **kwargs):
         return _grid.GridTableBase_SetColLabelValue(*args, **kwargs)
 
     def CanHaveAttributes(*args, **kwargs):

-        """CanHaveAttributes() -> bool"""
+        """CanHaveAttributes(self) -> bool"""

         return _grid.GridTableBase_CanHaveAttributes(*args, **kwargs)
 
     def GetAttr(*args, **kwargs):
         return _grid.GridTableBase_CanHaveAttributes(*args, **kwargs)
 
     def GetAttr(*args, **kwargs):

-        """GetAttr(int row, int col, int kind) -> GridCellAttr"""
+        """GetAttr(self, int row, int col, int kind) -> GridCellAttr"""

         return _grid.GridTableBase_GetAttr(*args, **kwargs)
 
     def SetAttr(*args, **kwargs):
         return _grid.GridTableBase_GetAttr(*args, **kwargs)
 
     def SetAttr(*args, **kwargs):

-        """SetAttr(GridCellAttr attr, int row, int col)"""
+        """SetAttr(self, GridCellAttr attr, int row, int col)"""

         return _grid.GridTableBase_SetAttr(*args, **kwargs)
 
     def SetRowAttr(*args, **kwargs):
         return _grid.GridTableBase_SetAttr(*args, **kwargs)
 
     def SetRowAttr(*args, **kwargs):

-        """SetRowAttr(GridCellAttr attr, int row)"""
+        """SetRowAttr(self, GridCellAttr attr, int row)"""

         return _grid.GridTableBase_SetRowAttr(*args, **kwargs)
 
     def SetColAttr(*args, **kwargs):
         return _grid.GridTableBase_SetRowAttr(*args, **kwargs)
 
     def SetColAttr(*args, **kwargs):

-        """SetColAttr(GridCellAttr attr, int col)"""
+        """SetColAttr(self, GridCellAttr attr, int col)"""

         return _grid.GridTableBase_SetColAttr(*args, **kwargs)
 
         return _grid.GridTableBase_SetColAttr(*args, **kwargs)
 

-
-class GridTableBasePtr(GridTableBase):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridTableBase
-_grid.GridTableBase_swigregister(GridTableBasePtr)
+GridTableBase_swigregister = _grid.GridTableBase_swigregister
+GridTableBase_swigregister(GridTableBase)

 
 class PyGridTableBase(GridTableBase):
 
 class PyGridTableBase(GridTableBase):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxPyGridTableBase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__() -> PyGridTableBase"""
-        newobj = _grid.new_PyGridTableBase(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ PyGridTableBase 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) -> PyGridTableBase"""
+        _grid.PyGridTableBase_swiginit(self,_grid.new_PyGridTableBase(*args, **kwargs))

         self._setCallbackInfo(self, PyGridTableBase);self._setOORInfo(self)
 
     def _setCallbackInfo(*args, **kwargs):
         self._setCallbackInfo(self, PyGridTableBase);self._setOORInfo(self)
 
     def _setCallbackInfo(*args, **kwargs):

-        """_setCallbackInfo(PyObject self, PyObject _class)"""
+        """_setCallbackInfo(self, PyObject self, PyObject _class)"""

         return _grid.PyGridTableBase__setCallbackInfo(*args, **kwargs)
 
     def Destroy(*args, **kwargs):
         """
         return _grid.PyGridTableBase__setCallbackInfo(*args, **kwargs)
 
     def Destroy(*args, **kwargs):
         """

-        Destroy()
+        Destroy(self)

 
         Deletes the C++ object this Python object is a proxy for.
         """
 
         Deletes the C++ object this Python object is a proxy for.
         """

-        return _grid.PyGridTableBase_Destroy(*args, **kwargs)
-
-    def base_GetTypeName(*args, **kwargs):
-        """base_GetTypeName(int row, int col) -> String"""
-        return _grid.PyGridTableBase_base_GetTypeName(*args, **kwargs)
-
-    def base_CanGetValueAs(*args, **kwargs):
-        """base_CanGetValueAs(int row, int col, String typeName) -> bool"""
-        return _grid.PyGridTableBase_base_CanGetValueAs(*args, **kwargs)
-
-    def base_CanSetValueAs(*args, **kwargs):
-        """base_CanSetValueAs(int row, int col, String typeName) -> bool"""
-        return _grid.PyGridTableBase_base_CanSetValueAs(*args, **kwargs)
-
-    def base_Clear(*args, **kwargs):
-        """base_Clear()"""
-        return _grid.PyGridTableBase_base_Clear(*args, **kwargs)
-
-    def base_InsertRows(*args, **kwargs):
-        """base_InsertRows(size_t pos=0, size_t numRows=1) -> bool"""
-        return _grid.PyGridTableBase_base_InsertRows(*args, **kwargs)
-
-    def base_AppendRows(*args, **kwargs):
-        """base_AppendRows(size_t numRows=1) -> bool"""
-        return _grid.PyGridTableBase_base_AppendRows(*args, **kwargs)
-
-    def base_DeleteRows(*args, **kwargs):
-        """base_DeleteRows(size_t pos=0, size_t numRows=1) -> bool"""
-        return _grid.PyGridTableBase_base_DeleteRows(*args, **kwargs)
-
-    def base_InsertCols(*args, **kwargs):
-        """base_InsertCols(size_t pos=0, size_t numCols=1) -> bool"""
-        return _grid.PyGridTableBase_base_InsertCols(*args, **kwargs)
-
-    def base_AppendCols(*args, **kwargs):
-        """base_AppendCols(size_t numCols=1) -> bool"""
-        return _grid.PyGridTableBase_base_AppendCols(*args, **kwargs)
-
-    def base_DeleteCols(*args, **kwargs):
-        """base_DeleteCols(size_t pos=0, size_t numCols=1) -> bool"""
-        return _grid.PyGridTableBase_base_DeleteCols(*args, **kwargs)
-
-    def base_GetRowLabelValue(*args, **kwargs):
-        """base_GetRowLabelValue(int row) -> String"""
-        return _grid.PyGridTableBase_base_GetRowLabelValue(*args, **kwargs)
-
-    def base_GetColLabelValue(*args, **kwargs):
-        """base_GetColLabelValue(int col) -> String"""
-        return _grid.PyGridTableBase_base_GetColLabelValue(*args, **kwargs)
-
-    def base_SetRowLabelValue(*args, **kwargs):
-        """base_SetRowLabelValue(int row, String value)"""
-        return _grid.PyGridTableBase_base_SetRowLabelValue(*args, **kwargs)
-
-    def base_SetColLabelValue(*args, **kwargs):
-        """base_SetColLabelValue(int col, String value)"""
-        return _grid.PyGridTableBase_base_SetColLabelValue(*args, **kwargs)
-
-    def base_CanHaveAttributes(*args, **kwargs):
-        """base_CanHaveAttributes() -> bool"""
-        return _grid.PyGridTableBase_base_CanHaveAttributes(*args, **kwargs)
-
-    def base_GetAttr(*args, **kwargs):
-        """base_GetAttr(int row, int col, int kind) -> GridCellAttr"""
-        return _grid.PyGridTableBase_base_GetAttr(*args, **kwargs)
-
-    def base_SetAttr(*args, **kwargs):
-        """base_SetAttr(GridCellAttr attr, int row, int col)"""
-        return _grid.PyGridTableBase_base_SetAttr(*args, **kwargs)
-
-    def base_SetRowAttr(*args, **kwargs):
-        """base_SetRowAttr(GridCellAttr attr, int row)"""
-        return _grid.PyGridTableBase_base_SetRowAttr(*args, **kwargs)
-
-    def base_SetColAttr(*args, **kwargs):
-        """base_SetColAttr(GridCellAttr attr, int col)"""
-        return _grid.PyGridTableBase_base_SetColAttr(*args, **kwargs)
-
-
-class PyGridTableBasePtr(PyGridTableBase):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = PyGridTableBase
-_grid.PyGridTableBase_swigregister(PyGridTableBasePtr)
+        val = _grid.PyGridTableBase_Destroy(*args, **kwargs)
+        args[0].thisown = 0
+        return val
+
+    def base_GetTypeName(*args, **kw):
+        return PyGridTableBase.GetTypeName(*args, **kw)
+    base_GetTypeName = wx._deprecated(base_GetTypeName,
+                                   "Please use PyGridTableBase.GetTypeName instead.")
+
+    def base_CanGetValueAs(*args, **kw):
+        return PyGridTableBase.CanGetValueAs(*args, **kw)
+    base_CanGetValueAs = wx._deprecated(base_CanGetValueAs,
+                                   "Please use PyGridTableBase.CanGetValueAs instead.")
+
+    def base_CanSetValueAs(*args, **kw):
+        return PyGridTableBase.CanSetValueAs(*args, **kw)
+    base_CanSetValueAs = wx._deprecated(base_CanSetValueAs,
+                                   "Please use PyGridTableBase.CanSetValueAs instead.")
+
+    def base_Clear(*args, **kw):
+        return PyGridTableBase.Clear(*args, **kw)
+    base_Clear = wx._deprecated(base_Clear,
+                                   "Please use PyGridTableBase.Clear instead.")
+
+    def base_InsertRows(*args, **kw):
+        return PyGridTableBase.InsertRows(*args, **kw)
+    base_InsertRows = wx._deprecated(base_InsertRows,
+                                   "Please use PyGridTableBase.InsertRows instead.")
+
+    def base_AppendRows(*args, **kw):
+        return PyGridTableBase.AppendRows(*args, **kw)
+    base_AppendRows = wx._deprecated(base_AppendRows,
+                                   "Please use PyGridTableBase.AppendRows instead.")
+
+    def base_DeleteRows(*args, **kw):
+        return PyGridTableBase.DeleteRows(*args, **kw)
+    base_DeleteRows = wx._deprecated(base_DeleteRows,
+                                   "Please use PyGridTableBase.DeleteRows instead.")
+
+    def base_InsertCols(*args, **kw):
+        return PyGridTableBase.InsertCols(*args, **kw)
+    base_InsertCols = wx._deprecated(base_InsertCols,
+                                   "Please use PyGridTableBase.InsertCols instead.")
+
+    def base_AppendCols(*args, **kw):
+        return PyGridTableBase.AppendCols(*args, **kw)
+    base_AppendCols = wx._deprecated(base_AppendCols,
+                                   "Please use PyGridTableBase.AppendCols instead.")
+
+    def base_DeleteCols(*args, **kw):
+        return PyGridTableBase.DeleteCols(*args, **kw)
+    base_DeleteCols = wx._deprecated(base_DeleteCols,
+                                   "Please use PyGridTableBase.DeleteCols instead.")
+
+    def base_GetRowLabelValue(*args, **kw):
+        return PyGridTableBase.GetRowLabelValue(*args, **kw)
+    base_GetRowLabelValue = wx._deprecated(base_GetRowLabelValue,
+                                   "Please use PyGridTableBase.GetRowLabelValue instead.")
+
+    def base_GetColLabelValue(*args, **kw):
+        return PyGridTableBase.GetColLabelValue(*args, **kw)
+    base_GetColLabelValue = wx._deprecated(base_GetColLabelValue,
+                                   "Please use PyGridTableBase.GetColLabelValue instead.")
+
+    def base_SetRowLabelValue(*args, **kw):
+        return PyGridTableBase.SetRowLabelValue(*args, **kw)
+    base_SetRowLabelValue = wx._deprecated(base_SetRowLabelValue,
+                                   "Please use PyGridTableBase.SetRowLabelValue instead.")
+
+    def base_SetColLabelValue(*args, **kw):
+        return PyGridTableBase.SetColLabelValue(*args, **kw)
+    base_SetColLabelValue = wx._deprecated(base_SetColLabelValue,
+                                   "Please use PyGridTableBase.SetColLabelValue instead.")
+
+    def base_CanHaveAttributes(*args, **kw):
+        return PyGridTableBase.CanHaveAttributes(*args, **kw)
+    base_CanHaveAttributes = wx._deprecated(base_CanHaveAttributes,
+                                   "Please use PyGridTableBase.CanHaveAttributes instead.")
+
+    def base_GetAttr(*args, **kw):
+        return PyGridTableBase.GetAttr(*args, **kw)
+    base_GetAttr = wx._deprecated(base_GetAttr,
+                                   "Please use PyGridTableBase.GetAttr instead.")
+
+    def base_SetAttr(*args, **kw):
+        return PyGridTableBase.SetAttr(*args, **kw)
+    base_SetAttr = wx._deprecated(base_SetAttr,
+                                   "Please use PyGridTableBase.SetAttr instead.")
+
+    def base_SetRowAttr(*args, **kw):
+        return PyGridTableBase.SetRowAttr(*args, **kw)
+    base_SetRowAttr = wx._deprecated(base_SetRowAttr,
+                                   "Please use PyGridTableBase.SetRowAttr instead.")
+
+    def base_SetColAttr(*args, **kw):
+        return PyGridTableBase.SetColAttr(*args, **kw)
+    base_SetColAttr = wx._deprecated(base_SetColAttr,
+                                   "Please use PyGridTableBase.SetColAttr instead.")
+
+PyGridTableBase_swigregister = _grid.PyGridTableBase_swigregister
+PyGridTableBase_swigregister(PyGridTableBase)

 
 class GridStringTable(GridTableBase):
 
 class GridStringTable(GridTableBase):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridStringTable instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(int numRows=0, int numCols=0) -> GridStringTable"""
-        newobj = _grid.new_GridStringTable(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+    """Proxy of C++ GridStringTable 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, int numRows=0, int numCols=0) -> GridStringTable"""
+        _grid.GridStringTable_swiginit(self,_grid.new_GridStringTable(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

-
-class GridStringTablePtr(GridStringTable):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridStringTable
-_grid.GridStringTable_swigregister(GridStringTablePtr)
+GridStringTable_swigregister = _grid.GridStringTable_swigregister
+GridStringTable_swigregister(GridStringTable)

 
 GRIDTABLE_REQUEST_VIEW_GET_VALUES = _grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES
 GRIDTABLE_REQUEST_VIEW_SEND_VALUES = _grid.GRIDTABLE_REQUEST_VIEW_SEND_VALUES
 
 GRIDTABLE_REQUEST_VIEW_GET_VALUES = _grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES
 GRIDTABLE_REQUEST_VIEW_SEND_VALUES = _grid.GRIDTABLE_REQUEST_VIEW_SEND_VALUES


@@ -1088,139 +1023,132 @@ GRIDTABLE_NOTIFY_COLS_INSERTED = _grid.GRIDTABLE_NOTIFY_COLS_INSERTED
 GRIDTABLE_NOTIFY_COLS_APPENDED = _grid.GRIDTABLE_NOTIFY_COLS_APPENDED
 GRIDTABLE_NOTIFY_COLS_DELETED = _grid.GRIDTABLE_NOTIFY_COLS_DELETED
 class GridTableMessage(object):
 GRIDTABLE_NOTIFY_COLS_APPENDED = _grid.GRIDTABLE_NOTIFY_COLS_APPENDED
 GRIDTABLE_NOTIFY_COLS_DELETED = _grid.GRIDTABLE_NOTIFY_COLS_DELETED
 class GridTableMessage(object):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridTableMessage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(GridTableBase table, int id, int comInt1=-1, int comInt2=-1) -> GridTableMessage"""
-        newobj = _grid.new_GridTableMessage(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
-    def __del__(self, destroy=_grid.delete_GridTableMessage):
-        """__del__()"""
-        try:
-            if self.thisown: destroy(self)
-        except: pass
-
+    """Proxy of C++ GridTableMessage 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, GridTableBase table, int id, int comInt1=-1, int comInt2=-1) -> GridTableMessage"""
+        _grid.GridTableMessage_swiginit(self,_grid.new_GridTableMessage(*args, **kwargs))
+    __swig_destroy__ = _grid.delete_GridTableMessage
+    __del__ = lambda self : None;

     def SetTableObject(*args, **kwargs):
     def SetTableObject(*args, **kwargs):

-        """SetTableObject(GridTableBase table)"""
+        """SetTableObject(self, GridTableBase table)"""

         return _grid.GridTableMessage_SetTableObject(*args, **kwargs)
 
     def GetTableObject(*args, **kwargs):
         return _grid.GridTableMessage_SetTableObject(*args, **kwargs)
 
     def GetTableObject(*args, **kwargs):

-        """GetTableObject() -> GridTableBase"""
+        """GetTableObject(self) -> GridTableBase"""

         return _grid.GridTableMessage_GetTableObject(*args, **kwargs)
 
     def SetId(*args, **kwargs):
         return _grid.GridTableMessage_GetTableObject(*args, **kwargs)
 
     def SetId(*args, **kwargs):

-        """SetId(int id)"""
+        """SetId(self, int id)"""

         return _grid.GridTableMessage_SetId(*args, **kwargs)
 
     def GetId(*args, **kwargs):
         return _grid.GridTableMessage_SetId(*args, **kwargs)
 
     def GetId(*args, **kwargs):

-        """GetId() -> int"""
+        """GetId(self) -> int"""

         return _grid.GridTableMessage_GetId(*args, **kwargs)
 
     def SetCommandInt(*args, **kwargs):
         return _grid.GridTableMessage_GetId(*args, **kwargs)
 
     def SetCommandInt(*args, **kwargs):

-        """SetCommandInt(int comInt1)"""
+        """SetCommandInt(self, int comInt1)"""

         return _grid.GridTableMessage_SetCommandInt(*args, **kwargs)
 
     def GetCommandInt(*args, **kwargs):
         return _grid.GridTableMessage_SetCommandInt(*args, **kwargs)
 
     def GetCommandInt(*args, **kwargs):

-        """GetCommandInt() -> int"""
+        """GetCommandInt(self) -> int"""

         return _grid.GridTableMessage_GetCommandInt(*args, **kwargs)
 
     def SetCommandInt2(*args, **kwargs):
         return _grid.GridTableMessage_GetCommandInt(*args, **kwargs)
 
     def SetCommandInt2(*args, **kwargs):

-        """SetCommandInt2(int comInt2)"""
+        """SetCommandInt2(self, int comInt2)"""

         return _grid.GridTableMessage_SetCommandInt2(*args, **kwargs)
 
     def GetCommandInt2(*args, **kwargs):
         return _grid.GridTableMessage_SetCommandInt2(*args, **kwargs)
 
     def GetCommandInt2(*args, **kwargs):

-        """GetCommandInt2() -> int"""
+        """GetCommandInt2(self) -> int"""

         return _grid.GridTableMessage_GetCommandInt2(*args, **kwargs)
 
         return _grid.GridTableMessage_GetCommandInt2(*args, **kwargs)
 

-
-class GridTableMessagePtr(GridTableMessage):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridTableMessage
-_grid.GridTableMessage_swigregister(GridTableMessagePtr)
+GridTableMessage_swigregister = _grid.GridTableMessage_swigregister
+GridTableMessage_swigregister(GridTableMessage)

 
 class GridCellCoords(object):
 
 class GridCellCoords(object):

-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridCellCoords instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """__init__(int r=-1, int c=-1) -> GridCellCoords"""
-        newobj = _grid.new_GridCellCoords(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
-    def __del__(self, destroy=_grid.delete_GridCellCoords):
-        """__del__()"""
-        try:
-            if self.thisown: destroy(self)
-        except: pass
-
+    """Proxy of C++ GridCellCoords 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, int r=-1, int c=-1) -> GridCellCoords"""
+        _grid.GridCellCoords_swiginit(self,_grid.new_GridCellCoords(*args, **kwargs))
+    __swig_destroy__ = _grid.delete_GridCellCoords
+    __del__ = lambda self : None;

     def GetRow(*args, **kwargs):
     def GetRow(*args, **kwargs):

-        """GetRow() -> int"""
+        """GetRow(self) -> int"""

         return _grid.GridCellCoords_GetRow(*args, **kwargs)
 
     def SetRow(*args, **kwargs):
         return _grid.GridCellCoords_GetRow(*args, **kwargs)
 
     def SetRow(*args, **kwargs):

-        """SetRow(int n)"""
+        """SetRow(self, int n)"""

         return _grid.GridCellCoords_SetRow(*args, **kwargs)
 
     def GetCol(*args, **kwargs):
         return _grid.GridCellCoords_SetRow(*args, **kwargs)
 
     def GetCol(*args, **kwargs):

-        """GetCol() -> int"""
+        """GetCol(self) -> int"""

         return _grid.GridCellCoords_GetCol(*args, **kwargs)
 
     def SetCol(*args, **kwargs):
         return _grid.GridCellCoords_GetCol(*args, **kwargs)
 
     def SetCol(*args, **kwargs):

-        """SetCol(int n)"""
+        """SetCol(self, int n)"""

         return _grid.GridCellCoords_SetCol(*args, **kwargs)
 
     def Set(*args, **kwargs):
         return _grid.GridCellCoords_SetCol(*args, **kwargs)
 
     def Set(*args, **kwargs):

-        """Set(int row, int col)"""
+        """Set(self, int row, int col)"""

         return _grid.GridCellCoords_Set(*args, **kwargs)
 
     def __eq__(*args, **kwargs):
         return _grid.GridCellCoords_Set(*args, **kwargs)
 
     def __eq__(*args, **kwargs):

-        """__eq__(GridCellCoords other) -> bool"""
+        """
+        __eq__(self, PyObject other) -> bool
+
+        Test for equality of GridCellCoords objects.
+        """

         return _grid.GridCellCoords___eq__(*args, **kwargs)
 
     def __ne__(*args, **kwargs):
         return _grid.GridCellCoords___eq__(*args, **kwargs)
 
     def __ne__(*args, **kwargs):

-        """__ne__(GridCellCoords other) -> bool"""
+        """
+        __ne__(self, PyObject other) -> bool
+
+        Test for inequality of GridCellCoords objects.
+        """

         return _grid.GridCellCoords___ne__(*args, **kwargs)
 
         return _grid.GridCellCoords___ne__(*args, **kwargs)
 

-    def asTuple(*args, **kwargs):
-        """asTuple() -> PyObject"""
-        return _grid.GridCellCoords_asTuple(*args, **kwargs)
+    def Get(*args, **kwargs):
+        """Get(self) -> PyObject"""
+        return _grid.GridCellCoords_Get(*args, **kwargs)

 
 

-    def __str__(self):                   return str(self.asTuple())
-    def __repr__(self):                  return 'wxGridCellCoords'+str(self.asTuple())
-    def __len__(self):                   return len(self.asTuple())
+    asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
+    def __str__(self):                   return str(self.Get())
+    def __repr__(self):                  return 'wxGridCellCoords'+str(self.Get())
+    def __len__(self):                   return len(self.Get())

     def __getitem__(self, index):        return self.asTuple()[index]
     def __setitem__(self, index, val):
         if index == 0: self.SetRow(val)
         elif index == 1: self.SetCol(val)
         else: raise IndexError
 
     def __getitem__(self, index):        return self.asTuple()[index]
     def __setitem__(self, index, val):
         if index == 0: self.SetRow(val)
         elif index == 1: self.SetCol(val)
         else: raise IndexError
 

+GridCellCoords_swigregister = _grid.GridCellCoords_swigregister
+GridCellCoords_swigregister(GridCellCoords)

 
 

-class GridCellCoordsPtr(GridCellCoords):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridCellCoords
-_grid.GridCellCoords_swigregister(GridCellCoordsPtr)
-
-class Grid(windows.ScrolledWindow):
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGrid instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
+class Grid(_windows.ScrolledWindow):
+    """Proxy of C++ Grid 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__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, 
-            long style=WANTS_CHARS, 
+        __init__(self, Window parent, int id=-1, Point pos=DefaultPosition, 
+            Size size=DefaultSize, long style=WANTS_CHARS, 

             String name=PanelNameStr) -> Grid
         """
             String name=PanelNameStr) -> Grid
         """

-        newobj = _grid.new_Grid(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+        _grid.Grid_swiginit(self,_grid.new_Grid(*args, **kwargs))

         self._setOORInfo(self)
 
         self._setOORInfo(self)
 

+    def Create(*args, **kwargs):
+        """
+        Create(self, Window parent, int id=-1, Point pos=DefaultPosition, 
+            Size size=DefaultSize, long style=WANTS_CHARS, 
+            String name=PanelNameStr) -> bool
+        """
+        return _grid.Grid_Create(*args, **kwargs)
+

     wxGridSelectCells = _grid.Grid_wxGridSelectCells
     wxGridSelectRows = _grid.Grid_wxGridSelectRows
     wxGridSelectColumns = _grid.Grid_wxGridSelectColumns
     wxGridSelectCells = _grid.Grid_wxGridSelectCells
     wxGridSelectRows = _grid.Grid_wxGridSelectRows
     wxGridSelectColumns = _grid.Grid_wxGridSelectColumns


@@ -1229,72 +1157,72 @@ class Grid(windows.ScrolledWindow):
     SelectColumns = wxGridSelectColumns
 
     def CreateGrid(*args, **kwargs):
     SelectColumns = wxGridSelectColumns
 
     def CreateGrid(*args, **kwargs):

-        """CreateGrid(int numRows, int numCols, WXGRIDSELECTIONMODES selmode=wxGridSelectCells) -> bool"""
+        """CreateGrid(self, int numRows, int numCols, WXGRIDSELECTIONMODES selmode=wxGridSelectCells) -> bool"""

         return _grid.Grid_CreateGrid(*args, **kwargs)
 
     def SetSelectionMode(*args, **kwargs):
         return _grid.Grid_CreateGrid(*args, **kwargs)
 
     def SetSelectionMode(*args, **kwargs):

-        """SetSelectionMode(WXGRIDSELECTIONMODES selmode)"""
+        """SetSelectionMode(self, WXGRIDSELECTIONMODES selmode)"""

         return _grid.Grid_SetSelectionMode(*args, **kwargs)
 
     def GetSelectionMode(*args, **kwargs):
         return _grid.Grid_SetSelectionMode(*args, **kwargs)
 
     def GetSelectionMode(*args, **kwargs):

-        """GetSelectionMode() -> WXGRIDSELECTIONMODES"""
+        """GetSelectionMode(self) -> WXGRIDSELECTIONMODES"""

         return _grid.Grid_GetSelectionMode(*args, **kwargs)
 
     def GetNumberRows(*args, **kwargs):
         return _grid.Grid_GetSelectionMode(*args, **kwargs)
 
     def GetNumberRows(*args, **kwargs):

-        """GetNumberRows() -> int"""
+        """GetNumberRows(self) -> int"""

         return _grid.Grid_GetNumberRows(*args, **kwargs)
 
     def GetNumberCols(*args, **kwargs):
         return _grid.Grid_GetNumberRows(*args, **kwargs)
 
     def GetNumberCols(*args, **kwargs):

-        """GetNumberCols() -> int"""
+        """GetNumberCols(self) -> int"""

         return _grid.Grid_GetNumberCols(*args, **kwargs)
 
     def ProcessTableMessage(*args, **kwargs):
         return _grid.Grid_GetNumberCols(*args, **kwargs)
 
     def ProcessTableMessage(*args, **kwargs):

-        """ProcessTableMessage(GridTableMessage ??) -> bool"""
+        """ProcessTableMessage(self, GridTableMessage ?) -> bool"""

         return _grid.Grid_ProcessTableMessage(*args, **kwargs)
 
     def GetTable(*args, **kwargs):
         return _grid.Grid_ProcessTableMessage(*args, **kwargs)
 
     def GetTable(*args, **kwargs):

-        """GetTable() -> GridTableBase"""
+        """GetTable(self) -> GridTableBase"""

         return _grid.Grid_GetTable(*args, **kwargs)
 
     def SetTable(*args, **kwargs):
         return _grid.Grid_GetTable(*args, **kwargs)
 
     def SetTable(*args, **kwargs):

-        """SetTable(GridTableBase table, bool takeOwnership=False, WXGRIDSELECTIONMODES selmode=wxGridSelectCells) -> bool"""
+        """SetTable(self, GridTableBase table, bool takeOwnership=False, WXGRIDSELECTIONMODES selmode=wxGridSelectCells) -> bool"""

         return _grid.Grid_SetTable(*args, **kwargs)
 
     def ClearGrid(*args, **kwargs):
         return _grid.Grid_SetTable(*args, **kwargs)
 
     def ClearGrid(*args, **kwargs):

-        """ClearGrid()"""
+        """ClearGrid(self)"""

         return _grid.Grid_ClearGrid(*args, **kwargs)
 
     def InsertRows(*args, **kwargs):
         return _grid.Grid_ClearGrid(*args, **kwargs)
 
     def InsertRows(*args, **kwargs):

-        """InsertRows(int pos=0, int numRows=1, bool updateLabels=True) -> bool"""
+        """InsertRows(self, int pos=0, int numRows=1, bool updateLabels=True) -> bool"""

         return _grid.Grid_InsertRows(*args, **kwargs)
 
     def AppendRows(*args, **kwargs):
         return _grid.Grid_InsertRows(*args, **kwargs)
 
     def AppendRows(*args, **kwargs):

-        """AppendRows(int numRows=1, bool updateLabels=True) -> bool"""
+        """AppendRows(self, int numRows=1, bool updateLabels=True) -> bool"""

         return _grid.Grid_AppendRows(*args, **kwargs)
 
     def DeleteRows(*args, **kwargs):
         return _grid.Grid_AppendRows(*args, **kwargs)
 
     def DeleteRows(*args, **kwargs):

-        """DeleteRows(int pos=0, int numRows=1, bool updateLabels=True) -> bool"""
+        """DeleteRows(self, int pos=0, int numRows=1, bool updateLabels=True) -> bool"""

         return _grid.Grid_DeleteRows(*args, **kwargs)
 
     def InsertCols(*args, **kwargs):
         return _grid.Grid_DeleteRows(*args, **kwargs)
 
     def InsertCols(*args, **kwargs):

-        """InsertCols(int pos=0, int numCols=1, bool updateLabels=True) -> bool"""
+        """InsertCols(self, int pos=0, int numCols=1, bool updateLabels=True) -> bool"""

         return _grid.Grid_InsertCols(*args, **kwargs)
 
     def AppendCols(*args, **kwargs):
         return _grid.Grid_InsertCols(*args, **kwargs)
 
     def AppendCols(*args, **kwargs):

-        """AppendCols(int numCols=1, bool updateLabels=True) -> bool"""
+        """AppendCols(self, int numCols=1, bool updateLabels=True) -> bool"""

         return _grid.Grid_AppendCols(*args, **kwargs)
 
     def DeleteCols(*args, **kwargs):
         return _grid.Grid_AppendCols(*args, **kwargs)
 
     def DeleteCols(*args, **kwargs):

-        """DeleteCols(int pos=0, int numCols=1, bool updateLabels=True) -> bool"""
+        """DeleteCols(self, int pos=0, int numCols=1, bool updateLabels=True) -> bool"""

         return _grid.Grid_DeleteCols(*args, **kwargs)
 
     def DrawCellHighlight(*args, **kwargs):
         return _grid.Grid_DeleteCols(*args, **kwargs)
 
     def DrawCellHighlight(*args, **kwargs):

-        """DrawCellHighlight(DC dc, GridCellAttr attr)"""
+        """DrawCellHighlight(self, DC dc, GridCellAttr attr)"""

         return _grid.Grid_DrawCellHighlight(*args, **kwargs)
 
     def DrawTextRectangle(*args, **kwargs):
         """
         return _grid.Grid_DrawCellHighlight(*args, **kwargs)
 
     def DrawTextRectangle(*args, **kwargs):
         """

-        DrawTextRectangle(DC dc, String ??, Rect ??, int horizontalAlignment=LEFT, 
+        DrawTextRectangle(self, DC dc, String ?, Rect ?, int horizontalAlignment=LEFT, 

             int verticalAlignment=TOP, int textOrientation=HORIZONTAL)
         """
         return _grid.Grid_DrawTextRectangle(*args, **kwargs)
             int verticalAlignment=TOP, int textOrientation=HORIZONTAL)
         """
         return _grid.Grid_DrawTextRectangle(*args, **kwargs)


@@ -1304,175 +1232,175 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetTextBoxSize(*args, **kwargs)
 
     def BeginBatch(*args, **kwargs):
         return _grid.Grid_GetTextBoxSize(*args, **kwargs)
 
     def BeginBatch(*args, **kwargs):

-        """BeginBatch()"""
+        """BeginBatch(self)"""

         return _grid.Grid_BeginBatch(*args, **kwargs)
 
     def EndBatch(*args, **kwargs):
         return _grid.Grid_BeginBatch(*args, **kwargs)
 
     def EndBatch(*args, **kwargs):

-        """EndBatch()"""
+        """EndBatch(self)"""

         return _grid.Grid_EndBatch(*args, **kwargs)
 
     def GetBatchCount(*args, **kwargs):
         return _grid.Grid_EndBatch(*args, **kwargs)
 
     def GetBatchCount(*args, **kwargs):

-        """GetBatchCount() -> int"""
+        """GetBatchCount(self) -> int"""

         return _grid.Grid_GetBatchCount(*args, **kwargs)
 
     def ForceRefresh(*args, **kwargs):
         return _grid.Grid_GetBatchCount(*args, **kwargs)
 
     def ForceRefresh(*args, **kwargs):

-        """ForceRefresh()"""
+        """ForceRefresh(self)"""

         return _grid.Grid_ForceRefresh(*args, **kwargs)
 
     def IsEditable(*args, **kwargs):
         return _grid.Grid_ForceRefresh(*args, **kwargs)
 
     def IsEditable(*args, **kwargs):

-        """IsEditable() -> bool"""
+        """IsEditable(self) -> bool"""

         return _grid.Grid_IsEditable(*args, **kwargs)
 
     def EnableEditing(*args, **kwargs):
         return _grid.Grid_IsEditable(*args, **kwargs)
 
     def EnableEditing(*args, **kwargs):

-        """EnableEditing(bool edit)"""
+        """EnableEditing(self, bool edit)"""

         return _grid.Grid_EnableEditing(*args, **kwargs)
 
     def EnableCellEditControl(*args, **kwargs):
         return _grid.Grid_EnableEditing(*args, **kwargs)
 
     def EnableCellEditControl(*args, **kwargs):

-        """EnableCellEditControl(bool enable=True)"""
+        """EnableCellEditControl(self, bool enable=True)"""

         return _grid.Grid_EnableCellEditControl(*args, **kwargs)
 
     def DisableCellEditControl(*args, **kwargs):
         return _grid.Grid_EnableCellEditControl(*args, **kwargs)
 
     def DisableCellEditControl(*args, **kwargs):

-        """DisableCellEditControl()"""
+        """DisableCellEditControl(self)"""

         return _grid.Grid_DisableCellEditControl(*args, **kwargs)
 
     def CanEnableCellControl(*args, **kwargs):
         return _grid.Grid_DisableCellEditControl(*args, **kwargs)
 
     def CanEnableCellControl(*args, **kwargs):

-        """CanEnableCellControl() -> bool"""
+        """CanEnableCellControl(self) -> bool"""

         return _grid.Grid_CanEnableCellControl(*args, **kwargs)
 
     def IsCellEditControlEnabled(*args, **kwargs):
         return _grid.Grid_CanEnableCellControl(*args, **kwargs)
 
     def IsCellEditControlEnabled(*args, **kwargs):

-        """IsCellEditControlEnabled() -> bool"""
+        """IsCellEditControlEnabled(self) -> bool"""

         return _grid.Grid_IsCellEditControlEnabled(*args, **kwargs)
 
     def IsCellEditControlShown(*args, **kwargs):
         return _grid.Grid_IsCellEditControlEnabled(*args, **kwargs)
 
     def IsCellEditControlShown(*args, **kwargs):

-        """IsCellEditControlShown() -> bool"""
+        """IsCellEditControlShown(self) -> bool"""

         return _grid.Grid_IsCellEditControlShown(*args, **kwargs)
 
     def IsCurrentCellReadOnly(*args, **kwargs):
         return _grid.Grid_IsCellEditControlShown(*args, **kwargs)
 
     def IsCurrentCellReadOnly(*args, **kwargs):

-        """IsCurrentCellReadOnly() -> bool"""
+        """IsCurrentCellReadOnly(self) -> bool"""

         return _grid.Grid_IsCurrentCellReadOnly(*args, **kwargs)
 
     def ShowCellEditControl(*args, **kwargs):
         return _grid.Grid_IsCurrentCellReadOnly(*args, **kwargs)
 
     def ShowCellEditControl(*args, **kwargs):

-        """ShowCellEditControl()"""
+        """ShowCellEditControl(self)"""

         return _grid.Grid_ShowCellEditControl(*args, **kwargs)
 
     def HideCellEditControl(*args, **kwargs):
         return _grid.Grid_ShowCellEditControl(*args, **kwargs)
 
     def HideCellEditControl(*args, **kwargs):

-        """HideCellEditControl()"""
+        """HideCellEditControl(self)"""

         return _grid.Grid_HideCellEditControl(*args, **kwargs)
 
     def SaveEditControlValue(*args, **kwargs):
         return _grid.Grid_HideCellEditControl(*args, **kwargs)
 
     def SaveEditControlValue(*args, **kwargs):

-        """SaveEditControlValue()"""
+        """SaveEditControlValue(self)"""

         return _grid.Grid_SaveEditControlValue(*args, **kwargs)
 
     def XYToCell(*args, **kwargs):
         return _grid.Grid_SaveEditControlValue(*args, **kwargs)
 
     def XYToCell(*args, **kwargs):

-        """XYToCell(int x, int y) -> GridCellCoords"""
+        """XYToCell(self, int x, int y) -> GridCellCoords"""

         return _grid.Grid_XYToCell(*args, **kwargs)
 
     def YToRow(*args, **kwargs):
         return _grid.Grid_XYToCell(*args, **kwargs)
 
     def YToRow(*args, **kwargs):

-        """YToRow(int y) -> int"""
+        """YToRow(self, int y) -> int"""

         return _grid.Grid_YToRow(*args, **kwargs)
 
     def XToCol(*args, **kwargs):
         return _grid.Grid_YToRow(*args, **kwargs)
 
     def XToCol(*args, **kwargs):

-        """XToCol(int x) -> int"""
+        """XToCol(self, int x) -> int"""

         return _grid.Grid_XToCol(*args, **kwargs)
 
     def YToEdgeOfRow(*args, **kwargs):
         return _grid.Grid_XToCol(*args, **kwargs)
 
     def YToEdgeOfRow(*args, **kwargs):

-        """YToEdgeOfRow(int y) -> int"""
+        """YToEdgeOfRow(self, int y) -> int"""

         return _grid.Grid_YToEdgeOfRow(*args, **kwargs)
 
     def XToEdgeOfCol(*args, **kwargs):
         return _grid.Grid_YToEdgeOfRow(*args, **kwargs)
 
     def XToEdgeOfCol(*args, **kwargs):

-        """XToEdgeOfCol(int x) -> int"""
+        """XToEdgeOfCol(self, int x) -> int"""

         return _grid.Grid_XToEdgeOfCol(*args, **kwargs)
 
     def CellToRect(*args, **kwargs):
         return _grid.Grid_XToEdgeOfCol(*args, **kwargs)
 
     def CellToRect(*args, **kwargs):

-        """CellToRect(int row, int col) -> Rect"""
+        """CellToRect(self, int row, int col) -> Rect"""

         return _grid.Grid_CellToRect(*args, **kwargs)
 
     def GetGridCursorRow(*args, **kwargs):
         return _grid.Grid_CellToRect(*args, **kwargs)
 
     def GetGridCursorRow(*args, **kwargs):

-        """GetGridCursorRow() -> int"""
+        """GetGridCursorRow(self) -> int"""

         return _grid.Grid_GetGridCursorRow(*args, **kwargs)
 
     def GetGridCursorCol(*args, **kwargs):
         return _grid.Grid_GetGridCursorRow(*args, **kwargs)
 
     def GetGridCursorCol(*args, **kwargs):

-        """GetGridCursorCol() -> int"""
+        """GetGridCursorCol(self) -> int"""

         return _grid.Grid_GetGridCursorCol(*args, **kwargs)
 
     def IsVisible(*args, **kwargs):
         return _grid.Grid_GetGridCursorCol(*args, **kwargs)
 
     def IsVisible(*args, **kwargs):

-        """IsVisible(int row, int col, bool wholeCellVisible=True) -> bool"""
+        """IsVisible(self, int row, int col, bool wholeCellVisible=True) -> bool"""

         return _grid.Grid_IsVisible(*args, **kwargs)
 
     def MakeCellVisible(*args, **kwargs):
         return _grid.Grid_IsVisible(*args, **kwargs)
 
     def MakeCellVisible(*args, **kwargs):

-        """MakeCellVisible(int row, int col)"""
+        """MakeCellVisible(self, int row, int col)"""

         return _grid.Grid_MakeCellVisible(*args, **kwargs)
 
     def SetGridCursor(*args, **kwargs):
         return _grid.Grid_MakeCellVisible(*args, **kwargs)
 
     def SetGridCursor(*args, **kwargs):

-        """SetGridCursor(int row, int col)"""
+        """SetGridCursor(self, int row, int col)"""

         return _grid.Grid_SetGridCursor(*args, **kwargs)
 
     def MoveCursorUp(*args, **kwargs):
         return _grid.Grid_SetGridCursor(*args, **kwargs)
 
     def MoveCursorUp(*args, **kwargs):

-        """MoveCursorUp(bool expandSelection) -> bool"""
+        """MoveCursorUp(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorUp(*args, **kwargs)
 
     def MoveCursorDown(*args, **kwargs):
         return _grid.Grid_MoveCursorUp(*args, **kwargs)
 
     def MoveCursorDown(*args, **kwargs):

-        """MoveCursorDown(bool expandSelection) -> bool"""
+        """MoveCursorDown(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorDown(*args, **kwargs)
 
     def MoveCursorLeft(*args, **kwargs):
         return _grid.Grid_MoveCursorDown(*args, **kwargs)
 
     def MoveCursorLeft(*args, **kwargs):

-        """MoveCursorLeft(bool expandSelection) -> bool"""
+        """MoveCursorLeft(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorLeft(*args, **kwargs)
 
     def MoveCursorRight(*args, **kwargs):
         return _grid.Grid_MoveCursorLeft(*args, **kwargs)
 
     def MoveCursorRight(*args, **kwargs):

-        """MoveCursorRight(bool expandSelection) -> bool"""
+        """MoveCursorRight(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorRight(*args, **kwargs)
 
     def MovePageDown(*args, **kwargs):
         return _grid.Grid_MoveCursorRight(*args, **kwargs)
 
     def MovePageDown(*args, **kwargs):

-        """MovePageDown() -> bool"""
+        """MovePageDown(self) -> bool"""

         return _grid.Grid_MovePageDown(*args, **kwargs)
 
     def MovePageUp(*args, **kwargs):
         return _grid.Grid_MovePageDown(*args, **kwargs)
 
     def MovePageUp(*args, **kwargs):

-        """MovePageUp() -> bool"""
+        """MovePageUp(self) -> bool"""

         return _grid.Grid_MovePageUp(*args, **kwargs)
 
     def MoveCursorUpBlock(*args, **kwargs):
         return _grid.Grid_MovePageUp(*args, **kwargs)
 
     def MoveCursorUpBlock(*args, **kwargs):

-        """MoveCursorUpBlock(bool expandSelection) -> bool"""
+        """MoveCursorUpBlock(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorUpBlock(*args, **kwargs)
 
     def MoveCursorDownBlock(*args, **kwargs):
         return _grid.Grid_MoveCursorUpBlock(*args, **kwargs)
 
     def MoveCursorDownBlock(*args, **kwargs):

-        """MoveCursorDownBlock(bool expandSelection) -> bool"""
+        """MoveCursorDownBlock(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorDownBlock(*args, **kwargs)
 
     def MoveCursorLeftBlock(*args, **kwargs):
         return _grid.Grid_MoveCursorDownBlock(*args, **kwargs)
 
     def MoveCursorLeftBlock(*args, **kwargs):

-        """MoveCursorLeftBlock(bool expandSelection) -> bool"""
+        """MoveCursorLeftBlock(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorLeftBlock(*args, **kwargs)
 
     def MoveCursorRightBlock(*args, **kwargs):
         return _grid.Grid_MoveCursorLeftBlock(*args, **kwargs)
 
     def MoveCursorRightBlock(*args, **kwargs):

-        """MoveCursorRightBlock(bool expandSelection) -> bool"""
+        """MoveCursorRightBlock(self, bool expandSelection) -> bool"""

         return _grid.Grid_MoveCursorRightBlock(*args, **kwargs)
 
     def GetDefaultRowLabelSize(*args, **kwargs):
         return _grid.Grid_MoveCursorRightBlock(*args, **kwargs)
 
     def GetDefaultRowLabelSize(*args, **kwargs):

-        """GetDefaultRowLabelSize() -> int"""
+        """GetDefaultRowLabelSize(self) -> int"""

         return _grid.Grid_GetDefaultRowLabelSize(*args, **kwargs)
 
     def GetRowLabelSize(*args, **kwargs):
         return _grid.Grid_GetDefaultRowLabelSize(*args, **kwargs)
 
     def GetRowLabelSize(*args, **kwargs):

-        """GetRowLabelSize() -> int"""
+        """GetRowLabelSize(self) -> int"""

         return _grid.Grid_GetRowLabelSize(*args, **kwargs)
 
     def GetDefaultColLabelSize(*args, **kwargs):
         return _grid.Grid_GetRowLabelSize(*args, **kwargs)
 
     def GetDefaultColLabelSize(*args, **kwargs):

-        """GetDefaultColLabelSize() -> int"""
+        """GetDefaultColLabelSize(self) -> int"""

         return _grid.Grid_GetDefaultColLabelSize(*args, **kwargs)
 
     def GetColLabelSize(*args, **kwargs):
         return _grid.Grid_GetDefaultColLabelSize(*args, **kwargs)
 
     def GetColLabelSize(*args, **kwargs):

-        """GetColLabelSize() -> int"""
+        """GetColLabelSize(self) -> int"""

         return _grid.Grid_GetColLabelSize(*args, **kwargs)
 
     def GetLabelBackgroundColour(*args, **kwargs):
         return _grid.Grid_GetColLabelSize(*args, **kwargs)
 
     def GetLabelBackgroundColour(*args, **kwargs):

-        """GetLabelBackgroundColour() -> Colour"""
+        """GetLabelBackgroundColour(self) -> Colour"""

         return _grid.Grid_GetLabelBackgroundColour(*args, **kwargs)
 
     def GetLabelTextColour(*args, **kwargs):
         return _grid.Grid_GetLabelBackgroundColour(*args, **kwargs)
 
     def GetLabelTextColour(*args, **kwargs):

-        """GetLabelTextColour() -> Colour"""
+        """GetLabelTextColour(self) -> Colour"""

         return _grid.Grid_GetLabelTextColour(*args, **kwargs)
 
     def GetLabelFont(*args, **kwargs):
         return _grid.Grid_GetLabelTextColour(*args, **kwargs)
 
     def GetLabelFont(*args, **kwargs):

-        """GetLabelFont() -> Font"""
+        """GetLabelFont(self) -> Font"""

         return _grid.Grid_GetLabelFont(*args, **kwargs)
 
     def GetRowLabelAlignment(*args, **kwargs):
         return _grid.Grid_GetLabelFont(*args, **kwargs)
 
     def GetRowLabelAlignment(*args, **kwargs):


@@ -1484,199 +1412,215 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetColLabelAlignment(*args, **kwargs)
 
     def GetColLabelTextOrientation(*args, **kwargs):
         return _grid.Grid_GetColLabelAlignment(*args, **kwargs)
 
     def GetColLabelTextOrientation(*args, **kwargs):

-        """GetColLabelTextOrientation() -> int"""
+        """GetColLabelTextOrientation(self) -> int"""

         return _grid.Grid_GetColLabelTextOrientation(*args, **kwargs)
 
     def GetRowLabelValue(*args, **kwargs):
         return _grid.Grid_GetColLabelTextOrientation(*args, **kwargs)
 
     def GetRowLabelValue(*args, **kwargs):

-        """GetRowLabelValue(int row) -> String"""
+        """GetRowLabelValue(self, int row) -> String"""

         return _grid.Grid_GetRowLabelValue(*args, **kwargs)
 
     def GetColLabelValue(*args, **kwargs):
         return _grid.Grid_GetRowLabelValue(*args, **kwargs)
 
     def GetColLabelValue(*args, **kwargs):

-        """GetColLabelValue(int col) -> String"""
+        """GetColLabelValue(self, int col) -> String"""

         return _grid.Grid_GetColLabelValue(*args, **kwargs)
 
     def GetGridLineColour(*args, **kwargs):
         return _grid.Grid_GetColLabelValue(*args, **kwargs)
 
     def GetGridLineColour(*args, **kwargs):

-        """GetGridLineColour() -> Colour"""
+        """GetGridLineColour(self) -> Colour"""

         return _grid.Grid_GetGridLineColour(*args, **kwargs)
 
     def GetCellHighlightColour(*args, **kwargs):
         return _grid.Grid_GetGridLineColour(*args, **kwargs)
 
     def GetCellHighlightColour(*args, **kwargs):

-        """GetCellHighlightColour() -> Colour"""
+        """GetCellHighlightColour(self) -> Colour"""

         return _grid.Grid_GetCellHighlightColour(*args, **kwargs)
 
     def GetCellHighlightPenWidth(*args, **kwargs):
         return _grid.Grid_GetCellHighlightColour(*args, **kwargs)
 
     def GetCellHighlightPenWidth(*args, **kwargs):

-        """GetCellHighlightPenWidth() -> int"""
+        """GetCellHighlightPenWidth(self) -> int"""

         return _grid.Grid_GetCellHighlightPenWidth(*args, **kwargs)
 
     def GetCellHighlightROPenWidth(*args, **kwargs):
         return _grid.Grid_GetCellHighlightPenWidth(*args, **kwargs)
 
     def GetCellHighlightROPenWidth(*args, **kwargs):

-        """GetCellHighlightROPenWidth() -> int"""
+        """GetCellHighlightROPenWidth(self) -> int"""

         return _grid.Grid_GetCellHighlightROPenWidth(*args, **kwargs)
 
     def SetRowLabelSize(*args, **kwargs):
         return _grid.Grid_GetCellHighlightROPenWidth(*args, **kwargs)
 
     def SetRowLabelSize(*args, **kwargs):

-        """SetRowLabelSize(int width)"""
+        """SetRowLabelSize(self, int width)"""

         return _grid.Grid_SetRowLabelSize(*args, **kwargs)
 
     def SetColLabelSize(*args, **kwargs):
         return _grid.Grid_SetRowLabelSize(*args, **kwargs)
 
     def SetColLabelSize(*args, **kwargs):

-        """SetColLabelSize(int height)"""
+        """SetColLabelSize(self, int height)"""

         return _grid.Grid_SetColLabelSize(*args, **kwargs)
 
     def SetLabelBackgroundColour(*args, **kwargs):
         return _grid.Grid_SetColLabelSize(*args, **kwargs)
 
     def SetLabelBackgroundColour(*args, **kwargs):

-        """SetLabelBackgroundColour(Colour ??)"""
+        """SetLabelBackgroundColour(self, Colour ?)"""

         return _grid.Grid_SetLabelBackgroundColour(*args, **kwargs)
 
     def SetLabelTextColour(*args, **kwargs):
         return _grid.Grid_SetLabelBackgroundColour(*args, **kwargs)
 
     def SetLabelTextColour(*args, **kwargs):

-        """SetLabelTextColour(Colour ??)"""
+        """SetLabelTextColour(self, Colour ?)"""

         return _grid.Grid_SetLabelTextColour(*args, **kwargs)
 
     def SetLabelFont(*args, **kwargs):
         return _grid.Grid_SetLabelTextColour(*args, **kwargs)
 
     def SetLabelFont(*args, **kwargs):

-        """SetLabelFont(Font ??)"""
+        """SetLabelFont(self, Font ?)"""

         return _grid.Grid_SetLabelFont(*args, **kwargs)
 
     def SetRowLabelAlignment(*args, **kwargs):
         return _grid.Grid_SetLabelFont(*args, **kwargs)
 
     def SetRowLabelAlignment(*args, **kwargs):

-        """SetRowLabelAlignment(int horiz, int vert)"""
+        """SetRowLabelAlignment(self, int horiz, int vert)"""

         return _grid.Grid_SetRowLabelAlignment(*args, **kwargs)
 
     def SetColLabelAlignment(*args, **kwargs):
         return _grid.Grid_SetRowLabelAlignment(*args, **kwargs)
 
     def SetColLabelAlignment(*args, **kwargs):

-        """SetColLabelAlignment(int horiz, int vert)"""
+        """SetColLabelAlignment(self, int horiz, int vert)"""

         return _grid.Grid_SetColLabelAlignment(*args, **kwargs)
 
     def SetColLabelTextOrientation(*args, **kwargs):
         return _grid.Grid_SetColLabelAlignment(*args, **kwargs)
 
     def SetColLabelTextOrientation(*args, **kwargs):

-        """SetColLabelTextOrientation(int textOrientation)"""
+        """SetColLabelTextOrientation(self, int textOrientation)"""

         return _grid.Grid_SetColLabelTextOrientation(*args, **kwargs)
 
     def SetRowLabelValue(*args, **kwargs):
         return _grid.Grid_SetColLabelTextOrientation(*args, **kwargs)
 
     def SetRowLabelValue(*args, **kwargs):

-        """SetRowLabelValue(int row, String ??)"""
+        """SetRowLabelValue(self, int row, String ?)"""

         return _grid.Grid_SetRowLabelValue(*args, **kwargs)
 
     def SetColLabelValue(*args, **kwargs):
         return _grid.Grid_SetRowLabelValue(*args, **kwargs)
 
     def SetColLabelValue(*args, **kwargs):

-        """SetColLabelValue(int col, String ??)"""
+        """SetColLabelValue(self, int col, String ?)"""

         return _grid.Grid_SetColLabelValue(*args, **kwargs)
 
     def SetGridLineColour(*args, **kwargs):
         return _grid.Grid_SetColLabelValue(*args, **kwargs)
 
     def SetGridLineColour(*args, **kwargs):

-        """SetGridLineColour(Colour ??)"""
+        """SetGridLineColour(self, Colour ?)"""

         return _grid.Grid_SetGridLineColour(*args, **kwargs)
 
     def SetCellHighlightColour(*args, **kwargs):
         return _grid.Grid_SetGridLineColour(*args, **kwargs)
 
     def SetCellHighlightColour(*args, **kwargs):

-        """SetCellHighlightColour(Colour ??)"""
+        """SetCellHighlightColour(self, Colour ?)"""

         return _grid.Grid_SetCellHighlightColour(*args, **kwargs)
 
     def SetCellHighlightPenWidth(*args, **kwargs):
         return _grid.Grid_SetCellHighlightColour(*args, **kwargs)
 
     def SetCellHighlightPenWidth(*args, **kwargs):

-        """SetCellHighlightPenWidth(int width)"""
+        """SetCellHighlightPenWidth(self, int width)"""

         return _grid.Grid_SetCellHighlightPenWidth(*args, **kwargs)
 
     def SetCellHighlightROPenWidth(*args, **kwargs):
         return _grid.Grid_SetCellHighlightPenWidth(*args, **kwargs)
 
     def SetCellHighlightROPenWidth(*args, **kwargs):

-        """SetCellHighlightROPenWidth(int width)"""
+        """SetCellHighlightROPenWidth(self, int width)"""

         return _grid.Grid_SetCellHighlightROPenWidth(*args, **kwargs)
 
     def EnableDragRowSize(*args, **kwargs):
         return _grid.Grid_SetCellHighlightROPenWidth(*args, **kwargs)
 
     def EnableDragRowSize(*args, **kwargs):

-        """EnableDragRowSize(bool enable=True)"""
+        """EnableDragRowSize(self, bool enable=True)"""

         return _grid.Grid_EnableDragRowSize(*args, **kwargs)
 
     def DisableDragRowSize(*args, **kwargs):
         return _grid.Grid_EnableDragRowSize(*args, **kwargs)
 
     def DisableDragRowSize(*args, **kwargs):

-        """DisableDragRowSize()"""
+        """DisableDragRowSize(self)"""

         return _grid.Grid_DisableDragRowSize(*args, **kwargs)
 
     def CanDragRowSize(*args, **kwargs):
         return _grid.Grid_DisableDragRowSize(*args, **kwargs)
 
     def CanDragRowSize(*args, **kwargs):

-        """CanDragRowSize() -> bool"""
+        """CanDragRowSize(self) -> bool"""

         return _grid.Grid_CanDragRowSize(*args, **kwargs)
 
     def EnableDragColSize(*args, **kwargs):
         return _grid.Grid_CanDragRowSize(*args, **kwargs)
 
     def EnableDragColSize(*args, **kwargs):

-        """EnableDragColSize(bool enable=True)"""
+        """EnableDragColSize(self, bool enable=True)"""

         return _grid.Grid_EnableDragColSize(*args, **kwargs)
 
     def DisableDragColSize(*args, **kwargs):
         return _grid.Grid_EnableDragColSize(*args, **kwargs)
 
     def DisableDragColSize(*args, **kwargs):

-        """DisableDragColSize()"""
+        """DisableDragColSize(self)"""

         return _grid.Grid_DisableDragColSize(*args, **kwargs)
 
     def CanDragColSize(*args, **kwargs):
         return _grid.Grid_DisableDragColSize(*args, **kwargs)
 
     def CanDragColSize(*args, **kwargs):

-        """CanDragColSize() -> bool"""
+        """CanDragColSize(self) -> bool"""

         return _grid.Grid_CanDragColSize(*args, **kwargs)
 
     def EnableDragGridSize(*args, **kwargs):
         return _grid.Grid_CanDragColSize(*args, **kwargs)
 
     def EnableDragGridSize(*args, **kwargs):

-        """EnableDragGridSize(bool enable=True)"""
+        """EnableDragGridSize(self, bool enable=True)"""

         return _grid.Grid_EnableDragGridSize(*args, **kwargs)
 
     def DisableDragGridSize(*args, **kwargs):
         return _grid.Grid_EnableDragGridSize(*args, **kwargs)
 
     def DisableDragGridSize(*args, **kwargs):

-        """DisableDragGridSize()"""
+        """DisableDragGridSize(self)"""

         return _grid.Grid_DisableDragGridSize(*args, **kwargs)
 
     def CanDragGridSize(*args, **kwargs):
         return _grid.Grid_DisableDragGridSize(*args, **kwargs)
 
     def CanDragGridSize(*args, **kwargs):

-        """CanDragGridSize() -> bool"""
+        """CanDragGridSize(self) -> bool"""

         return _grid.Grid_CanDragGridSize(*args, **kwargs)
 
         return _grid.Grid_CanDragGridSize(*args, **kwargs)
 

+    def EnableDragCell(*args, **kwargs):
+        """EnableDragCell(self, bool enable=True)"""
+        return _grid.Grid_EnableDragCell(*args, **kwargs)
+
+    def DisableDragCell(*args, **kwargs):
+        """DisableDragCell(self)"""
+        return _grid.Grid_DisableDragCell(*args, **kwargs)
+
+    def CanDragCell(*args, **kwargs):
+        """CanDragCell(self) -> bool"""
+        return _grid.Grid_CanDragCell(*args, **kwargs)
+

     def SetAttr(*args, **kwargs):
     def SetAttr(*args, **kwargs):

-        """SetAttr(int row, int col, GridCellAttr attr)"""
+        """SetAttr(self, int row, int col, GridCellAttr attr)"""

         return _grid.Grid_SetAttr(*args, **kwargs)
 
     def SetRowAttr(*args, **kwargs):
         return _grid.Grid_SetAttr(*args, **kwargs)
 
     def SetRowAttr(*args, **kwargs):

-        """SetRowAttr(int row, GridCellAttr attr)"""
+        """SetRowAttr(self, int row, GridCellAttr attr)"""

         return _grid.Grid_SetRowAttr(*args, **kwargs)
 
     def SetColAttr(*args, **kwargs):
         return _grid.Grid_SetRowAttr(*args, **kwargs)
 
     def SetColAttr(*args, **kwargs):

-        """SetColAttr(int col, GridCellAttr attr)"""
+        """SetColAttr(self, int col, GridCellAttr attr)"""

         return _grid.Grid_SetColAttr(*args, **kwargs)
 
         return _grid.Grid_SetColAttr(*args, **kwargs)
 

+    def GetOrCreateCellAttr(*args, **kwargs):
+        """GetOrCreateCellAttr(self, int row, int col) -> GridCellAttr"""
+        return _grid.Grid_GetOrCreateCellAttr(*args, **kwargs)
+

     def SetColFormatBool(*args, **kwargs):
     def SetColFormatBool(*args, **kwargs):

-        """SetColFormatBool(int col)"""
+        """SetColFormatBool(self, int col)"""

         return _grid.Grid_SetColFormatBool(*args, **kwargs)
 
     def SetColFormatNumber(*args, **kwargs):
         return _grid.Grid_SetColFormatBool(*args, **kwargs)
 
     def SetColFormatNumber(*args, **kwargs):

-        """SetColFormatNumber(int col)"""
+        """SetColFormatNumber(self, int col)"""

         return _grid.Grid_SetColFormatNumber(*args, **kwargs)
 
     def SetColFormatFloat(*args, **kwargs):
         return _grid.Grid_SetColFormatNumber(*args, **kwargs)
 
     def SetColFormatFloat(*args, **kwargs):

-        """SetColFormatFloat(int col, int width=-1, int precision=-1)"""
+        """SetColFormatFloat(self, int col, int width=-1, int precision=-1)"""

         return _grid.Grid_SetColFormatFloat(*args, **kwargs)
 
     def SetColFormatCustom(*args, **kwargs):
         return _grid.Grid_SetColFormatFloat(*args, **kwargs)
 
     def SetColFormatCustom(*args, **kwargs):

-        """SetColFormatCustom(int col, String typeName)"""
+        """SetColFormatCustom(self, int col, String typeName)"""

         return _grid.Grid_SetColFormatCustom(*args, **kwargs)
 
     def EnableGridLines(*args, **kwargs):
         return _grid.Grid_SetColFormatCustom(*args, **kwargs)
 
     def EnableGridLines(*args, **kwargs):

-        """EnableGridLines(bool enable=True)"""
+        """EnableGridLines(self, bool enable=True)"""

         return _grid.Grid_EnableGridLines(*args, **kwargs)
 
     def GridLinesEnabled(*args, **kwargs):
         return _grid.Grid_EnableGridLines(*args, **kwargs)
 
     def GridLinesEnabled(*args, **kwargs):

-        """GridLinesEnabled() -> bool"""
+        """GridLinesEnabled(self) -> bool"""

         return _grid.Grid_GridLinesEnabled(*args, **kwargs)
 
     def GetDefaultRowSize(*args, **kwargs):
         return _grid.Grid_GridLinesEnabled(*args, **kwargs)
 
     def GetDefaultRowSize(*args, **kwargs):

-        """GetDefaultRowSize() -> int"""
+        """GetDefaultRowSize(self) -> int"""

         return _grid.Grid_GetDefaultRowSize(*args, **kwargs)
 
     def GetRowSize(*args, **kwargs):
         return _grid.Grid_GetDefaultRowSize(*args, **kwargs)
 
     def GetRowSize(*args, **kwargs):

-        """GetRowSize(int row) -> int"""
+        """GetRowSize(self, int row) -> int"""

         return _grid.Grid_GetRowSize(*args, **kwargs)
 
     def GetDefaultColSize(*args, **kwargs):
         return _grid.Grid_GetRowSize(*args, **kwargs)
 
     def GetDefaultColSize(*args, **kwargs):

-        """GetDefaultColSize() -> int"""
+        """GetDefaultColSize(self) -> int"""

         return _grid.Grid_GetDefaultColSize(*args, **kwargs)
 
     def GetColSize(*args, **kwargs):
         return _grid.Grid_GetDefaultColSize(*args, **kwargs)
 
     def GetColSize(*args, **kwargs):

-        """GetColSize(int col) -> int"""
+        """GetColSize(self, int col) -> int"""

         return _grid.Grid_GetColSize(*args, **kwargs)
 
     def GetDefaultCellBackgroundColour(*args, **kwargs):
         return _grid.Grid_GetColSize(*args, **kwargs)
 
     def GetDefaultCellBackgroundColour(*args, **kwargs):

-        """GetDefaultCellBackgroundColour() -> Colour"""
+        """GetDefaultCellBackgroundColour(self) -> Colour"""

         return _grid.Grid_GetDefaultCellBackgroundColour(*args, **kwargs)
 
     def GetCellBackgroundColour(*args, **kwargs):
         return _grid.Grid_GetDefaultCellBackgroundColour(*args, **kwargs)
 
     def GetCellBackgroundColour(*args, **kwargs):

-        """GetCellBackgroundColour(int row, int col) -> Colour"""
+        """GetCellBackgroundColour(self, int row, int col) -> Colour"""

         return _grid.Grid_GetCellBackgroundColour(*args, **kwargs)
 
     def GetDefaultCellTextColour(*args, **kwargs):
         return _grid.Grid_GetCellBackgroundColour(*args, **kwargs)
 
     def GetDefaultCellTextColour(*args, **kwargs):

-        """GetDefaultCellTextColour() -> Colour"""
+        """GetDefaultCellTextColour(self) -> Colour"""

         return _grid.Grid_GetDefaultCellTextColour(*args, **kwargs)
 
     def GetCellTextColour(*args, **kwargs):
         return _grid.Grid_GetDefaultCellTextColour(*args, **kwargs)
 
     def GetCellTextColour(*args, **kwargs):

-        """GetCellTextColour(int row, int col) -> Colour"""
+        """GetCellTextColour(self, int row, int col) -> Colour"""

         return _grid.Grid_GetCellTextColour(*args, **kwargs)
 
     def GetDefaultCellFont(*args, **kwargs):
         return _grid.Grid_GetCellTextColour(*args, **kwargs)
 
     def GetDefaultCellFont(*args, **kwargs):

-        """GetDefaultCellFont() -> Font"""
+        """GetDefaultCellFont(self) -> Font"""

         return _grid.Grid_GetDefaultCellFont(*args, **kwargs)
 
     def GetCellFont(*args, **kwargs):
         return _grid.Grid_GetDefaultCellFont(*args, **kwargs)
 
     def GetCellFont(*args, **kwargs):

-        """GetCellFont(int row, int col) -> Font"""
+        """GetCellFont(self, int row, int col) -> Font"""

         return _grid.Grid_GetCellFont(*args, **kwargs)
 
     def GetDefaultCellAlignment(*args, **kwargs):
         return _grid.Grid_GetCellFont(*args, **kwargs)
 
     def GetDefaultCellAlignment(*args, **kwargs):


@@ -1688,11 +1632,11 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetCellAlignment(*args, **kwargs)
 
     def GetDefaultCellOverflow(*args, **kwargs):
         return _grid.Grid_GetCellAlignment(*args, **kwargs)
 
     def GetDefaultCellOverflow(*args, **kwargs):

-        """GetDefaultCellOverflow() -> bool"""
+        """GetDefaultCellOverflow(self) -> bool"""

         return _grid.Grid_GetDefaultCellOverflow(*args, **kwargs)
 
     def GetCellOverflow(*args, **kwargs):
         return _grid.Grid_GetDefaultCellOverflow(*args, **kwargs)
 
     def GetCellOverflow(*args, **kwargs):

-        """GetCellOverflow(int row, int col) -> bool"""
+        """GetCellOverflow(self, int row, int col) -> bool"""

         return _grid.Grid_GetCellOverflow(*args, **kwargs)
 
     def GetCellSize(*args, **kwargs):
         return _grid.Grid_GetCellOverflow(*args, **kwargs)
 
     def GetCellSize(*args, **kwargs):


@@ -1700,504 +1644,547 @@ class Grid(windows.ScrolledWindow):
         return _grid.Grid_GetCellSize(*args, **kwargs)
 
     def SetDefaultRowSize(*args, **kwargs):
         return _grid.Grid_GetCellSize(*args, **kwargs)
 
     def SetDefaultRowSize(*args, **kwargs):

-        """SetDefaultRowSize(int height, bool resizeExistingRows=False)"""
+        """SetDefaultRowSize(self, int height, bool resizeExistingRows=False)"""

         return _grid.Grid_SetDefaultRowSize(*args, **kwargs)
 
     def SetRowSize(*args, **kwargs):
         return _grid.Grid_SetDefaultRowSize(*args, **kwargs)
 
     def SetRowSize(*args, **kwargs):

-        """SetRowSize(int row, int height)"""
+        """SetRowSize(self, int row, int height)"""

         return _grid.Grid_SetRowSize(*args, **kwargs)
 
     def SetDefaultColSize(*args, **kwargs):
         return _grid.Grid_SetRowSize(*args, **kwargs)
 
     def SetDefaultColSize(*args, **kwargs):

-        """SetDefaultColSize(int width, bool resizeExistingCols=False)"""
+        """SetDefaultColSize(self, int width, bool resizeExistingCols=False)"""

         return _grid.Grid_SetDefaultColSize(*args, **kwargs)
 
     def SetColSize(*args, **kwargs):
         return _grid.Grid_SetDefaultColSize(*args, **kwargs)
 
     def SetColSize(*args, **kwargs):

-        """SetColSize(int col, int width)"""
+        """SetColSize(self, int col, int width)"""

         return _grid.Grid_SetColSize(*args, **kwargs)
 
     def AutoSizeColumn(*args, **kwargs):
         return _grid.Grid_SetColSize(*args, **kwargs)
 
     def AutoSizeColumn(*args, **kwargs):

-        """AutoSizeColumn(int col, bool setAsMin=True)"""
+        """AutoSizeColumn(self, int col, bool setAsMin=True)"""

         return _grid.Grid_AutoSizeColumn(*args, **kwargs)
 
     def AutoSizeRow(*args, **kwargs):
         return _grid.Grid_AutoSizeColumn(*args, **kwargs)
 
     def AutoSizeRow(*args, **kwargs):

-        """AutoSizeRow(int row, bool setAsMin=True)"""
+        """AutoSizeRow(self, int row, bool setAsMin=True)"""

         return _grid.Grid_AutoSizeRow(*args, **kwargs)
 
     def AutoSizeColumns(*args, **kwargs):
         return _grid.Grid_AutoSizeRow(*args, **kwargs)
 
     def AutoSizeColumns(*args, **kwargs):

-        """AutoSizeColumns(bool setAsMin=True)"""
+        """AutoSizeColumns(self, bool setAsMin=True)"""

         return _grid.Grid_AutoSizeColumns(*args, **kwargs)
 
     def AutoSizeRows(*args, **kwargs):
         return _grid.Grid_AutoSizeColumns(*args, **kwargs)
 
     def AutoSizeRows(*args, **kwargs):

-        """AutoSizeRows(bool setAsMin=True)"""
+        """AutoSizeRows(self, bool setAsMin=True)"""

         return _grid.Grid_AutoSizeRows(*args, **kwargs)
 
     def AutoSize(*args, **kwargs):
         return _grid.Grid_AutoSizeRows(*args, **kwargs)
 
     def AutoSize(*args, **kwargs):

-        """AutoSize()"""
+        """AutoSize(self)"""

         return _grid.Grid_AutoSize(*args, **kwargs)
 
     def AutoSizeRowLabelSize(*args, **kwargs):
         return _grid.Grid_AutoSize(*args, **kwargs)
 
     def AutoSizeRowLabelSize(*args, **kwargs):

-        """AutoSizeRowLabelSize(int row)"""
+        """AutoSizeRowLabelSize(self, int row)"""

         return _grid.Grid_AutoSizeRowLabelSize(*args, **kwargs)
 
     def AutoSizeColLabelSize(*args, **kwargs):
         return _grid.Grid_AutoSizeRowLabelSize(*args, **kwargs)
 
     def AutoSizeColLabelSize(*args, **kwargs):

-        """AutoSizeColLabelSize(int col)"""
+        """AutoSizeColLabelSize(self, int col)"""

         return _grid.Grid_AutoSizeColLabelSize(*args, **kwargs)
 
     def SetColMinimalWidth(*args, **kwargs):
         return _grid.Grid_AutoSizeColLabelSize(*args, **kwargs)
 
     def SetColMinimalWidth(*args, **kwargs):

-        """SetColMinimalWidth(int col, int width)"""
+        """SetColMinimalWidth(self, int col, int width)"""

         return _grid.Grid_SetColMinimalWidth(*args, **kwargs)
 
     def SetRowMinimalHeight(*args, **kwargs):
         return _grid.Grid_SetColMinimalWidth(*args, **kwargs)
 
     def SetRowMinimalHeight(*args, **kwargs):

-        """SetRowMinimalHeight(int row, int width)"""
+        """SetRowMinimalHeight(self, int row, int width)"""

         return _grid.Grid_SetRowMinimalHeight(*args, **kwargs)
 
     def SetColMinimalAcceptableWidth(*args, **kwargs):
         return _grid.Grid_SetRowMinimalHeight(*args, **kwargs)
 
     def SetColMinimalAcceptableWidth(*args, **kwargs):

-        """SetColMinimalAcceptableWidth(int width)"""
+        """SetColMinimalAcceptableWidth(self, int width)"""

         return _grid.Grid_SetColMinimalAcceptableWidth(*args, **kwargs)
 
     def SetRowMinimalAcceptableHeight(*args, **kwargs):
         return _grid.Grid_SetColMinimalAcceptableWidth(*args, **kwargs)
 
     def SetRowMinimalAcceptableHeight(*args, **kwargs):

-        """SetRowMinimalAcceptableHeight(int width)"""
+        """SetRowMinimalAcceptableHeight(self, int width)"""

         return _grid.Grid_SetRowMinimalAcceptableHeight(*args, **kwargs)
 
     def GetColMinimalAcceptableWidth(*args, **kwargs):
         return _grid.Grid_SetRowMinimalAcceptableHeight(*args, **kwargs)
 
     def GetColMinimalAcceptableWidth(*args, **kwargs):

-        """GetColMinimalAcceptableWidth() -> int"""
+        """GetColMinimalAcceptableWidth(self) -> int"""

         return _grid.Grid_GetColMinimalAcceptableWidth(*args, **kwargs)
 
     def GetRowMinimalAcceptableHeight(*args, **kwargs):
         return _grid.Grid_GetColMinimalAcceptableWidth(*args, **kwargs)
 
     def GetRowMinimalAcceptableHeight(*args, **kwargs):

-        """GetRowMinimalAcceptableHeight() -> int"""
+        """GetRowMinimalAcceptableHeight(self) -> int"""

         return _grid.Grid_GetRowMinimalAcceptableHeight(*args, **kwargs)
 
     def SetDefaultCellBackgroundColour(*args, **kwargs):
         return _grid.Grid_GetRowMinimalAcceptableHeight(*args, **kwargs)
 
     def SetDefaultCellBackgroundColour(*args, **kwargs):

-        """SetDefaultCellBackgroundColour(Colour ??)"""
+        """SetDefaultCellBackgroundColour(self, Colour ?)"""

         return _grid.Grid_SetDefaultCellBackgroundColour(*args, **kwargs)
 
     def SetCellBackgroundColour(*args, **kwargs):
         return _grid.Grid_SetDefaultCellBackgroundColour(*args, **kwargs)
 
     def SetCellBackgroundColour(*args, **kwargs):

-        """SetCellBackgroundColour(int row, int col, Colour ??)"""
+        """SetCellBackgroundColour(self, int row, int col, Colour ?)"""

         return _grid.Grid_SetCellBackgroundColour(*args, **kwargs)
 
     def SetDefaultCellTextColour(*args, **kwargs):
         return _grid.Grid_SetCellBackgroundColour(*args, **kwargs)
 
     def SetDefaultCellTextColour(*args, **kwargs):

-        """SetDefaultCellTextColour(Colour ??)"""
+        """SetDefaultCellTextColour(self, Colour ?)"""

         return _grid.Grid_SetDefaultCellTextColour(*args, **kwargs)
 
     def SetCellTextColour(*args, **kwargs):
         return _grid.Grid_SetDefaultCellTextColour(*args, **kwargs)
 
     def SetCellTextColour(*args, **kwargs):

-        """SetCellTextColour(int row, int col, Colour ??)"""
+        """SetCellTextColour(self, int row, int col, Colour ?)"""

         return _grid.Grid_SetCellTextColour(*args, **kwargs)
 
     def SetDefaultCellFont(*args, **kwargs):
         return _grid.Grid_SetCellTextColour(*args, **kwargs)
 
     def SetDefaultCellFont(*args, **kwargs):

-        """SetDefaultCellFont(Font ??)"""
+        """SetDefaultCellFont(self, Font ?)"""

         return _grid.Grid_SetDefaultCellFont(*args, **kwargs)
 
     def SetCellFont(*args, **kwargs):
         return _grid.Grid_SetDefaultCellFont(*args, **kwargs)
 
     def SetCellFont(*args, **kwargs):

-        """SetCellFont(int row, int col, Font ??)"""
+        """SetCellFont(self, int row, int col, Font ?)"""

         return _grid.Grid_SetCellFont(*args, **kwargs)
 
     def SetDefaultCellAlignment(*args, **kwargs):
         return _grid.Grid_SetCellFont(*args, **kwargs)
 
     def SetDefaultCellAlignment(*args, **kwargs):

-        """SetDefaultCellAlignment(int horiz, int vert)"""
+        """SetDefaultCellAlignment(self, int horiz, int vert)"""

         return _grid.Grid_SetDefaultCellAlignment(*args, **kwargs)
 
     def SetCellAlignment(*args, **kwargs):
         return _grid.Grid_SetDefaultCellAlignment(*args, **kwargs)
 
     def SetCellAlignment(*args, **kwargs):

-        """SetCellAlignment(int row, int col, int horiz, int vert)"""
+        """SetCellAlignment(self, int row, int col, int horiz, int vert)"""

         return _grid.Grid_SetCellAlignment(*args, **kwargs)
 
     def SetDefaultCellOverflow(*args, **kwargs):
         return _grid.Grid_SetCellAlignment(*args, **kwargs)
 
     def SetDefaultCellOverflow(*args, **kwargs):

-        """SetDefaultCellOverflow(bool allow)"""
+        """SetDefaultCellOverflow(self, bool allow)"""

         return _grid.Grid_SetDefaultCellOverflow(*args, **kwargs)
 
     def SetCellOverflow(*args, **kwargs):
         return _grid.Grid_SetDefaultCellOverflow(*args, **kwargs)
 
     def SetCellOverflow(*args, **kwargs):

-        """SetCellOverflow(int row, int col, bool allow)"""
+        """SetCellOverflow(self, int row, int col, bool allow)"""

         return _grid.Grid_SetCellOverflow(*args, **kwargs)
 
     def SetCellSize(*args, **kwargs):
         return _grid.Grid_SetCellOverflow(*args, **kwargs)
 
     def SetCellSize(*args, **kwargs):

-        """SetCellSize(int row, int col, int num_rows, int num_cols)"""
+        """SetCellSize(self, int row, int col, int num_rows, int num_cols)"""

         return _grid.Grid_SetCellSize(*args, **kwargs)
 
     def SetDefaultRenderer(*args, **kwargs):
         return _grid.Grid_SetCellSize(*args, **kwargs)
 
     def SetDefaultRenderer(*args, **kwargs):

-        """SetDefaultRenderer(GridCellRenderer renderer)"""
+        """SetDefaultRenderer(self, GridCellRenderer renderer)"""

         return _grid.Grid_SetDefaultRenderer(*args, **kwargs)
 
     def SetCellRenderer(*args, **kwargs):
         return _grid.Grid_SetDefaultRenderer(*args, **kwargs)
 
     def SetCellRenderer(*args, **kwargs):

-        """SetCellRenderer(int row, int col, GridCellRenderer renderer)"""
+        """SetCellRenderer(self, int row, int col, GridCellRenderer renderer)"""

         return _grid.Grid_SetCellRenderer(*args, **kwargs)
 
     def GetDefaultRenderer(*args, **kwargs):
         return _grid.Grid_SetCellRenderer(*args, **kwargs)
 
     def GetDefaultRenderer(*args, **kwargs):

-        """GetDefaultRenderer() -> GridCellRenderer"""
+        """GetDefaultRenderer(self) -> GridCellRenderer"""

         return _grid.Grid_GetDefaultRenderer(*args, **kwargs)
 
     def GetCellRenderer(*args, **kwargs):
         return _grid.Grid_GetDefaultRenderer(*args, **kwargs)
 
     def GetCellRenderer(*args, **kwargs):

-        """GetCellRenderer(int row, int col) -> GridCellRenderer"""
+        """GetCellRenderer(self, int row, int col) -> GridCellRenderer"""

         return _grid.Grid_GetCellRenderer(*args, **kwargs)
 
     def SetDefaultEditor(*args, **kwargs):
         return _grid.Grid_GetCellRenderer(*args, **kwargs)
 
     def SetDefaultEditor(*args, **kwargs):

-        """SetDefaultEditor(GridCellEditor editor)"""
+        """SetDefaultEditor(self, GridCellEditor editor)"""

         return _grid.Grid_SetDefaultEditor(*args, **kwargs)
 
     def SetCellEditor(*args, **kwargs):
         return _grid.Grid_SetDefaultEditor(*args, **kwargs)
 
     def SetCellEditor(*args, **kwargs):

-        """SetCellEditor(int row, int col, GridCellEditor editor)"""
+        """SetCellEditor(self, int row, int col, GridCellEditor editor)"""

         return _grid.Grid_SetCellEditor(*args, **kwargs)
 
     def GetDefaultEditor(*args, **kwargs):
         return _grid.Grid_SetCellEditor(*args, **kwargs)
 
     def GetDefaultEditor(*args, **kwargs):

-        """GetDefaultEditor() -> GridCellEditor"""
+        """GetDefaultEditor(self) -> GridCellEditor"""

         return _grid.Grid_GetDefaultEditor(*args, **kwargs)
 
     def GetCellEditor(*args, **kwargs):
         return _grid.Grid_GetDefaultEditor(*args, **kwargs)
 
     def GetCellEditor(*args, **kwargs):

-        """GetCellEditor(int row, int col) -> GridCellEditor"""
+        """GetCellEditor(self, int row, int col) -> GridCellEditor"""

         return _grid.Grid_GetCellEditor(*args, **kwargs)
 
     def GetCellValue(*args, **kwargs):
         return _grid.Grid_GetCellEditor(*args, **kwargs)
 
     def GetCellValue(*args, **kwargs):

-        """GetCellValue(int row, int col) -> String"""
+        """GetCellValue(self, int row, int col) -> String"""

         return _grid.Grid_GetCellValue(*args, **kwargs)
 
     def SetCellValue(*args, **kwargs):
         return _grid.Grid_GetCellValue(*args, **kwargs)
 
     def SetCellValue(*args, **kwargs):

-        """SetCellValue(int row, int col, String s)"""
+        """SetCellValue(self, int row, int col, String s)"""

         return _grid.Grid_SetCellValue(*args, **kwargs)
 
     def IsReadOnly(*args, **kwargs):
         return _grid.Grid_SetCellValue(*args, **kwargs)
 
     def IsReadOnly(*args, **kwargs):

-        """IsReadOnly(int row, int col) -> bool"""
+        """IsReadOnly(self, int row, int col) -> bool"""

         return _grid.Grid_IsReadOnly(*args, **kwargs)
 
     def SetReadOnly(*args, **kwargs):
         return _grid.Grid_IsReadOnly(*args, **kwargs)
 
     def SetReadOnly(*args, **kwargs):

-        """SetReadOnly(int row, int col, bool isReadOnly=True)"""
+        """SetReadOnly(self, int row, int col, bool isReadOnly=True)"""

         return _grid.Grid_SetReadOnly(*args, **kwargs)
 
     def SelectRow(*args, **kwargs):
         return _grid.Grid_SetReadOnly(*args, **kwargs)
 
     def SelectRow(*args, **kwargs):

-        """SelectRow(int row, bool addToSelected=False)"""
+        """SelectRow(self, int row, bool addToSelected=False)"""

         return _grid.Grid_SelectRow(*args, **kwargs)
 
     def SelectCol(*args, **kwargs):
         return _grid.Grid_SelectRow(*args, **kwargs)
 
     def SelectCol(*args, **kwargs):

-        """SelectCol(int col, bool addToSelected=False)"""
+        """SelectCol(self, int col, bool addToSelected=False)"""

         return _grid.Grid_SelectCol(*args, **kwargs)
 
     def SelectBlock(*args, **kwargs):
         """
         return _grid.Grid_SelectCol(*args, **kwargs)
 
     def SelectBlock(*args, **kwargs):
         """

-        SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol, 
+        SelectBlock(self, int topRow, int leftCol, int bottomRow, int rightCol, 

             bool addToSelected=False)
         """
         return _grid.Grid_SelectBlock(*args, **kwargs)
 
     def SelectAll(*args, **kwargs):
             bool addToSelected=False)
         """
         return _grid.Grid_SelectBlock(*args, **kwargs)
 
     def SelectAll(*args, **kwargs):

-        """SelectAll()"""
+        """SelectAll(self)"""

         return _grid.Grid_SelectAll(*args, **kwargs)
 
     def IsSelection(*args, **kwargs):
         return _grid.Grid_SelectAll(*args, **kwargs)
 
     def IsSelection(*args, **kwargs):

-        """IsSelection() -> bool"""
+        """IsSelection(self) -> bool"""

         return _grid.Grid_IsSelection(*args, **kwargs)
 
     def ClearSelection(*args, **kwargs):
         return _grid.Grid_IsSelection(*args, **kwargs)
 
     def ClearSelection(*args, **kwargs):

-        """ClearSelection()"""
+        """ClearSelection(self)"""

         return _grid.Grid_ClearSelection(*args, **kwargs)
 
     def IsInSelection(*args, **kwargs):
         return _grid.Grid_ClearSelection(*args, **kwargs)
 
     def IsInSelection(*args, **kwargs):

-        """IsInSelection(int row, int col) -> bool"""
+        """IsInSelection(self, int row, int col) -> bool"""

         return _grid.Grid_IsInSelection(*args, **kwargs)
 
     def GetSelectedCells(*args, **kwargs):
         return _grid.Grid_IsInSelection(*args, **kwargs)
 
     def GetSelectedCells(*args, **kwargs):

-        """GetSelectedCells() -> wxGridCellCoordsArray"""
+        """GetSelectedCells(self) -> wxGridCellCoordsArray"""

         return _grid.Grid_GetSelectedCells(*args, **kwargs)
 
     def GetSelectionBlockTopLeft(*args, **kwargs):
         return _grid.Grid_GetSelectedCells(*args, **kwargs)
 
     def GetSelectionBlockTopLeft(*args, **kwargs):

-        """GetSelectionBlockTopLeft() -> wxGridCellCoordsArray"""
+        """GetSelectionBlockTopLeft(self) -> wxGridCellCoordsArray"""

         return _grid.Grid_GetSelectionBlockTopLeft(*args, **kwargs)
 
     def GetSelectionBlockBottomRight(*args, **kwargs):
         return _grid.Grid_GetSelectionBlockTopLeft(*args, **kwargs)
 
     def GetSelectionBlockBottomRight(*args, **kwargs):

-        """GetSelectionBlockBottomRight() -> wxGridCellCoordsArray"""
+        """GetSelectionBlockBottomRight(self) -> wxGridCellCoordsArray"""

         return _grid.Grid_GetSelectionBlockBottomRight(*args, **kwargs)
 
     def GetSelectedRows(*args, **kwargs):
         return _grid.Grid_GetSelectionBlockBottomRight(*args, **kwargs)
 
     def GetSelectedRows(*args, **kwargs):

-        """GetSelectedRows() -> wxArrayInt"""
+        """GetSelectedRows(self) -> wxArrayInt"""

         return _grid.Grid_GetSelectedRows(*args, **kwargs)
 
     def GetSelectedCols(*args, **kwargs):
         return _grid.Grid_GetSelectedRows(*args, **kwargs)
 
     def GetSelectedCols(*args, **kwargs):

-        """GetSelectedCols() -> wxArrayInt"""
+        """GetSelectedCols(self) -> wxArrayInt"""

         return _grid.Grid_GetSelectedCols(*args, **kwargs)
 
     def DeselectRow(*args, **kwargs):
         return _grid.Grid_GetSelectedCols(*args, **kwargs)
 
     def DeselectRow(*args, **kwargs):

-        """DeselectRow(int row)"""
+        """DeselectRow(self, int row)"""

         return _grid.Grid_DeselectRow(*args, **kwargs)
 
     def DeselectCol(*args, **kwargs):
         return _grid.Grid_DeselectRow(*args, **kwargs)
 
     def DeselectCol(*args, **kwargs):

-        """DeselectCol(int col)"""
+        """DeselectCol(self, int col)"""

         return _grid.Grid_DeselectCol(*args, **kwargs)
 
     def DeselectCell(*args, **kwargs):
         return _grid.Grid_DeselectCol(*args, **kwargs)
 
     def DeselectCell(*args, **kwargs):

-        """DeselectCell(int row, int col)"""
+        """DeselectCell(self, int row, int col)"""

         return _grid.Grid_DeselectCell(*args, **kwargs)
 
     def BlockToDeviceRect(*args, **kwargs):
         return _grid.Grid_DeselectCell(*args, **kwargs)
 
     def BlockToDeviceRect(*args, **kwargs):

-        """BlockToDeviceRect(GridCellCoords topLeft, GridCellCoords bottomRight) -> Rect"""
+        """BlockToDeviceRect(self, GridCellCoords topLeft, GridCellCoords bottomRight) -> Rect"""

         return _grid.Grid_BlockToDeviceRect(*args, **kwargs)
 
     def GetSelectionBackground(*args, **kwargs):
         return _grid.Grid_BlockToDeviceRect(*args, **kwargs)
 
     def GetSelectionBackground(*args, **kwargs):

-        """GetSelectionBackground() -> Colour"""
+        """GetSelectionBackground(self) -> Colour"""

         return _grid.Grid_GetSelectionBackground(*args, **kwargs)
 
     def GetSelectionForeground(*args, **kwargs):
         return _grid.Grid_GetSelectionBackground(*args, **kwargs)
 
     def GetSelectionForeground(*args, **kwargs):

-        """GetSelectionForeground() -> Colour"""
+        """GetSelectionForeground(self) -> Colour"""

         return _grid.Grid_GetSelectionForeground(*args, **kwargs)
 
     def SetSelectionBackground(*args, **kwargs):
         return _grid.Grid_GetSelectionForeground(*args, **kwargs)
 
     def SetSelectionBackground(*args, **kwargs):

-        """SetSelectionBackground(Colour c)"""
+        """SetSelectionBackground(self, Colour c)"""

         return _grid.Grid_SetSelectionBackground(*args, **kwargs)
 
     def SetSelectionForeground(*args, **kwargs):
         return _grid.Grid_SetSelectionBackground(*args, **kwargs)
 
     def SetSelectionForeground(*args, **kwargs):

-        """SetSelectionForeground(Colour c)"""
+        """SetSelectionForeground(self, Colour c)"""

         return _grid.Grid_SetSelectionForeground(*args, **kwargs)
 
     def RegisterDataType(*args, **kwargs):
         return _grid.Grid_SetSelectionForeground(*args, **kwargs)
 
     def RegisterDataType(*args, **kwargs):

-        """RegisterDataType(String typeName, GridCellRenderer renderer, GridCellEditor editor)"""
+        """RegisterDataType(self, String typeName, GridCellRenderer renderer, GridCellEditor editor)"""

         return _grid.Grid_RegisterDataType(*args, **kwargs)
 
     def GetDefaultEditorForCell(*args, **kwargs):
         return _grid.Grid_RegisterDataType(*args, **kwargs)
 
     def GetDefaultEditorForCell(*args, **kwargs):

-        """GetDefaultEditorForCell(int row, int col) -> GridCellEditor"""
+        """GetDefaultEditorForCell(self, int row, int col) -> GridCellEditor"""

         return _grid.Grid_GetDefaultEditorForCell(*args, **kwargs)
 
     def GetDefaultRendererForCell(*args, **kwargs):
         return _grid.Grid_GetDefaultEditorForCell(*args, **kwargs)
 
     def GetDefaultRendererForCell(*args, **kwargs):

-        """GetDefaultRendererForCell(int row, int col) -> GridCellRenderer"""
+        """GetDefaultRendererForCell(self, int row, int col) -> GridCellRenderer"""

         return _grid.Grid_GetDefaultRendererForCell(*args, **kwargs)
 
     def GetDefaultEditorForType(*args, **kwargs):
         return _grid.Grid_GetDefaultRendererForCell(*args, **kwargs)
 
     def GetDefaultEditorForType(*args, **kwargs):

-        """GetDefaultEditorForType(String typeName) -> GridCellEditor"""
+        """GetDefaultEditorForType(self, String typeName) -> GridCellEditor"""

         return _grid.Grid_GetDefaultEditorForType(*args, **kwargs)
 
     def GetDefaultRendererForType(*args, **kwargs):
         return _grid.Grid_GetDefaultEditorForType(*args, **kwargs)
 
     def GetDefaultRendererForType(*args, **kwargs):

-        """GetDefaultRendererForType(String typeName) -> GridCellRenderer"""
+        """GetDefaultRendererForType(self, String typeName) -> GridCellRenderer"""

         return _grid.Grid_GetDefaultRendererForType(*args, **kwargs)
 
     def SetMargins(*args, **kwargs):
         return _grid.Grid_GetDefaultRendererForType(*args, **kwargs)
 
     def SetMargins(*args, **kwargs):

-        """SetMargins(int extraWidth, int extraHeight)"""
+        """SetMargins(self, int extraWidth, int extraHeight)"""

         return _grid.Grid_SetMargins(*args, **kwargs)
 
     def GetGridWindow(*args, **kwargs):
         return _grid.Grid_SetMargins(*args, **kwargs)
 
     def GetGridWindow(*args, **kwargs):

-        """GetGridWindow() -> Window"""
+        """GetGridWindow(self) -> Window"""

         return _grid.Grid_GetGridWindow(*args, **kwargs)
 
     def GetGridRowLabelWindow(*args, **kwargs):
         return _grid.Grid_GetGridWindow(*args, **kwargs)
 
     def GetGridRowLabelWindow(*args, **kwargs):

-        """GetGridRowLabelWindow() -> Window"""
+        """GetGridRowLabelWindow(self) -> Window"""

         return _grid.Grid_GetGridRowLabelWindow(*args, **kwargs)
 
     def GetGridColLabelWindow(*args, **kwargs):
         return _grid.Grid_GetGridRowLabelWindow(*args, **kwargs)
 
     def GetGridColLabelWindow(*args, **kwargs):

-        """GetGridColLabelWindow() -> Window"""
+        """GetGridColLabelWindow(self) -> Window"""

         return _grid.Grid_GetGridColLabelWindow(*args, **kwargs)
 
     def GetGridCornerLabelWindow(*args, **kwargs):
         return _grid.Grid_GetGridColLabelWindow(*args, **kwargs)
 
     def GetGridCornerLabelWindow(*args, **kwargs):

-        """GetGridCornerLabelWindow() -> Window"""
+        """GetGridCornerLabelWindow(self) -> Window"""

         return _grid.Grid_GetGridCornerLabelWindow(*args, **kwargs)
 
         return _grid.Grid_GetGridCornerLabelWindow(*args, **kwargs)
 

+    def SetScrollLineX(*args, **kwargs):
+        """SetScrollLineX(self, int x)"""
+        return _grid.Grid_SetScrollLineX(*args, **kwargs)
+
+    def SetScrollLineY(*args, **kwargs):
+        """SetScrollLineY(self, int y)"""
+        return _grid.Grid_SetScrollLineY(*args, **kwargs)

 
 

-class GridPtr(Grid):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = Grid
-_grid.Grid_swigregister(GridPtr)
+    def GetScrollLineX(*args, **kwargs):
+        """GetScrollLineX(self) -> int"""
+        return _grid.Grid_GetScrollLineX(*args, **kwargs)

 
 

-class GridEvent(core.NotifyEvent):
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
+    def GetScrollLineY(*args, **kwargs):
+        """GetScrollLineY(self) -> int"""
+        return _grid.Grid_GetScrollLineY(*args, **kwargs)
+
+    def GetScrollX(*args, **kwargs):
+        """GetScrollX(self, int x) -> int"""
+        return _grid.Grid_GetScrollX(*args, **kwargs)
+
+    def GetScrollY(*args, **kwargs):
+        """GetScrollY(self, int y) -> int"""
+        return _grid.Grid_GetScrollY(*args, **kwargs)
+
+    def GetClassDefaultAttributes(*args, **kwargs):
+        """
+        GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
+
+        Get the default attributes for this class.  This is useful if you want
+        to use the same font or colour in your own control as in a standard
+        control -- which is a much better idea than hard coding specific
+        colours or fonts which might look completely out of place on the
+        user's system, especially if it uses themes.
+
+        The variant parameter is only relevant under Mac currently and is
+        ignore under other platforms. Under Mac, it will change the size of
+        the returned font. See `wx.Window.SetWindowVariant` for more about
+        this.

         """
         """

-        __init__(int id, wxEventType type, Grid obj, int row=-1, int col=-1, 
+        return _grid.Grid_GetClassDefaultAttributes(*args, **kwargs)
+
+    GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
+Grid_swigregister = _grid.Grid_swigregister
+Grid_swigregister(Grid)
+
+def PreGrid(*args, **kwargs):
+    """PreGrid() -> Grid"""
+    val = _grid.new_PreGrid(*args, **kwargs)
+    return val
+
+def Grid_GetClassDefaultAttributes(*args, **kwargs):
+  """
+    Grid_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
+
+    Get the default attributes for this class.  This is useful if you want
+    to use the same font or colour in your own control as in a standard
+    control -- which is a much better idea than hard coding specific
+    colours or fonts which might look completely out of place on the
+    user's system, especially if it uses themes.
+
+    The variant parameter is only relevant under Mac currently and is
+    ignore under other platforms. Under Mac, it will change the size of
+    the returned font. See `wx.Window.SetWindowVariant` for more about
+    this.
+    """
+  return _grid.Grid_GetClassDefaultAttributes(*args, **kwargs)
+
+class GridEvent(_core.NotifyEvent):
+    """Proxy of C++ GridEvent 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, int id, wxEventType type, Grid obj, int row=-1, int col=-1, 

             int x=-1, int y=-1, bool sel=True, bool control=False, 
             bool shift=False, bool alt=False, 
             bool meta=False) -> GridEvent
         """
             int x=-1, int y=-1, bool sel=True, bool control=False, 
             bool shift=False, bool alt=False, 
             bool meta=False) -> GridEvent
         """

-        newobj = _grid.new_GridEvent(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+        _grid.GridEvent_swiginit(self,_grid.new_GridEvent(*args, **kwargs))

     def GetRow(*args, **kwargs):
     def GetRow(*args, **kwargs):

-        """GetRow() -> int"""
+        """GetRow(self) -> int"""

         return _grid.GridEvent_GetRow(*args, **kwargs)
 
     def GetCol(*args, **kwargs):
         return _grid.GridEvent_GetRow(*args, **kwargs)
 
     def GetCol(*args, **kwargs):

-        """GetCol() -> int"""
+        """GetCol(self) -> int"""

         return _grid.GridEvent_GetCol(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         return _grid.GridEvent_GetCol(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):

-        """GetPosition() -> Point"""
+        """GetPosition(self) -> Point"""

         return _grid.GridEvent_GetPosition(*args, **kwargs)
 
     def Selecting(*args, **kwargs):
         return _grid.GridEvent_GetPosition(*args, **kwargs)
 
     def Selecting(*args, **kwargs):

-        """Selecting() -> bool"""
+        """Selecting(self) -> bool"""

         return _grid.GridEvent_Selecting(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):
         return _grid.GridEvent_Selecting(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):

-        """ControlDown() -> bool"""
+        """ControlDown(self) -> bool"""

         return _grid.GridEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):
         return _grid.GridEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):

-        """MetaDown() -> bool"""
+        """MetaDown(self) -> bool"""

         return _grid.GridEvent_MetaDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):
         return _grid.GridEvent_MetaDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):

-        """ShiftDown() -> bool"""
+        """ShiftDown(self) -> bool"""

         return _grid.GridEvent_ShiftDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):
         return _grid.GridEvent_ShiftDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):

-        """AltDown() -> bool"""
+        """AltDown(self) -> bool"""

         return _grid.GridEvent_AltDown(*args, **kwargs)
 
         return _grid.GridEvent_AltDown(*args, **kwargs)
 

+    def CmdDown(*args, **kwargs):
+        """CmdDown(self) -> bool"""
+        return _grid.GridEvent_CmdDown(*args, **kwargs)

 
 

-class GridEventPtr(GridEvent):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridEvent
-_grid.GridEvent_swigregister(GridEventPtr)
+GridEvent_swigregister = _grid.GridEvent_swigregister
+GridEvent_swigregister(GridEvent)

 
 

-class GridSizeEvent(core.NotifyEvent):
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridSizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
+class GridSizeEvent(_core.NotifyEvent):
+    """Proxy of C++ GridSizeEvent 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__(int id, wxEventType type, Grid obj, int rowOrCol=-1, 
+        __init__(self, int id, wxEventType type, Grid obj, int rowOrCol=-1, 

             int x=-1, int y=-1, bool control=False, bool shift=False, 
             bool alt=False, bool meta=False) -> GridSizeEvent
         """
             int x=-1, int y=-1, bool control=False, bool shift=False, 
             bool alt=False, bool meta=False) -> GridSizeEvent
         """

-        newobj = _grid.new_GridSizeEvent(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+        _grid.GridSizeEvent_swiginit(self,_grid.new_GridSizeEvent(*args, **kwargs))

     def GetRowOrCol(*args, **kwargs):
     def GetRowOrCol(*args, **kwargs):

-        """GetRowOrCol() -> int"""
+        """GetRowOrCol(self) -> int"""

         return _grid.GridSizeEvent_GetRowOrCol(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):
         return _grid.GridSizeEvent_GetRowOrCol(*args, **kwargs)
 
     def GetPosition(*args, **kwargs):

-        """GetPosition() -> Point"""
+        """GetPosition(self) -> Point"""

         return _grid.GridSizeEvent_GetPosition(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):
         return _grid.GridSizeEvent_GetPosition(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):

-        """ControlDown() -> bool"""
+        """ControlDown(self) -> bool"""

         return _grid.GridSizeEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):
         return _grid.GridSizeEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):

-        """MetaDown() -> bool"""
+        """MetaDown(self) -> bool"""

         return _grid.GridSizeEvent_MetaDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):
         return _grid.GridSizeEvent_MetaDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):

-        """ShiftDown() -> bool"""
+        """ShiftDown(self) -> bool"""

         return _grid.GridSizeEvent_ShiftDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):
         return _grid.GridSizeEvent_ShiftDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):

-        """AltDown() -> bool"""
+        """AltDown(self) -> bool"""

         return _grid.GridSizeEvent_AltDown(*args, **kwargs)
 
         return _grid.GridSizeEvent_AltDown(*args, **kwargs)
 

+    def CmdDown(*args, **kwargs):
+        """CmdDown(self) -> bool"""
+        return _grid.GridSizeEvent_CmdDown(*args, **kwargs)

 
 

-class GridSizeEventPtr(GridSizeEvent):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridSizeEvent
-_grid.GridSizeEvent_swigregister(GridSizeEventPtr)
+GridSizeEvent_swigregister = _grid.GridSizeEvent_swigregister
+GridSizeEvent_swigregister(GridSizeEvent)

 
 

-class GridRangeSelectEvent(core.NotifyEvent):
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridRangeSelectEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
+class GridRangeSelectEvent(_core.NotifyEvent):
+    """Proxy of C++ GridRangeSelectEvent 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__(int id, wxEventType type, Grid obj, GridCellCoords topLeft, 
+        __init__(self, int id, wxEventType type, Grid obj, GridCellCoords topLeft, 

             GridCellCoords bottomRight, bool sel=True, 
             bool control=False, bool shift=False, 
             bool alt=False, bool meta=False) -> GridRangeSelectEvent
         """
             GridCellCoords bottomRight, bool sel=True, 
             bool control=False, bool shift=False, 
             bool alt=False, bool meta=False) -> GridRangeSelectEvent
         """

-        newobj = _grid.new_GridRangeSelectEvent(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+        _grid.GridRangeSelectEvent_swiginit(self,_grid.new_GridRangeSelectEvent(*args, **kwargs))

     def GetTopLeftCoords(*args, **kwargs):
     def GetTopLeftCoords(*args, **kwargs):

-        """GetTopLeftCoords() -> GridCellCoords"""
+        """GetTopLeftCoords(self) -> GridCellCoords"""

         return _grid.GridRangeSelectEvent_GetTopLeftCoords(*args, **kwargs)
 
     def GetBottomRightCoords(*args, **kwargs):
         return _grid.GridRangeSelectEvent_GetTopLeftCoords(*args, **kwargs)
 
     def GetBottomRightCoords(*args, **kwargs):

-        """GetBottomRightCoords() -> GridCellCoords"""
+        """GetBottomRightCoords(self) -> GridCellCoords"""

         return _grid.GridRangeSelectEvent_GetBottomRightCoords(*args, **kwargs)
 
     def GetTopRow(*args, **kwargs):
         return _grid.GridRangeSelectEvent_GetBottomRightCoords(*args, **kwargs)
 
     def GetTopRow(*args, **kwargs):

-        """GetTopRow() -> int"""
+        """GetTopRow(self) -> int"""

         return _grid.GridRangeSelectEvent_GetTopRow(*args, **kwargs)
 
     def GetBottomRow(*args, **kwargs):
         return _grid.GridRangeSelectEvent_GetTopRow(*args, **kwargs)
 
     def GetBottomRow(*args, **kwargs):

-        """GetBottomRow() -> int"""
+        """GetBottomRow(self) -> int"""

         return _grid.GridRangeSelectEvent_GetBottomRow(*args, **kwargs)
 
     def GetLeftCol(*args, **kwargs):
         return _grid.GridRangeSelectEvent_GetBottomRow(*args, **kwargs)
 
     def GetLeftCol(*args, **kwargs):

-        """GetLeftCol() -> int"""
+        """GetLeftCol(self) -> int"""

         return _grid.GridRangeSelectEvent_GetLeftCol(*args, **kwargs)
 
     def GetRightCol(*args, **kwargs):
         return _grid.GridRangeSelectEvent_GetLeftCol(*args, **kwargs)
 
     def GetRightCol(*args, **kwargs):

-        """GetRightCol() -> int"""
+        """GetRightCol(self) -> int"""

         return _grid.GridRangeSelectEvent_GetRightCol(*args, **kwargs)
 
     def Selecting(*args, **kwargs):
         return _grid.GridRangeSelectEvent_GetRightCol(*args, **kwargs)
 
     def Selecting(*args, **kwargs):

-        """Selecting() -> bool"""
+        """Selecting(self) -> bool"""

         return _grid.GridRangeSelectEvent_Selecting(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):
         return _grid.GridRangeSelectEvent_Selecting(*args, **kwargs)
 
     def ControlDown(*args, **kwargs):

-        """ControlDown() -> bool"""
+        """ControlDown(self) -> bool"""

         return _grid.GridRangeSelectEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):
         return _grid.GridRangeSelectEvent_ControlDown(*args, **kwargs)
 
     def MetaDown(*args, **kwargs):

-        """MetaDown() -> bool"""
+        """MetaDown(self) -> bool"""

         return _grid.GridRangeSelectEvent_MetaDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):
         return _grid.GridRangeSelectEvent_MetaDown(*args, **kwargs)
 
     def ShiftDown(*args, **kwargs):

-        """ShiftDown() -> bool"""
+        """ShiftDown(self) -> bool"""

         return _grid.GridRangeSelectEvent_ShiftDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):
         return _grid.GridRangeSelectEvent_ShiftDown(*args, **kwargs)
 
     def AltDown(*args, **kwargs):

-        """AltDown() -> bool"""
+        """AltDown(self) -> bool"""

         return _grid.GridRangeSelectEvent_AltDown(*args, **kwargs)
 
         return _grid.GridRangeSelectEvent_AltDown(*args, **kwargs)
 

+    def CmdDown(*args, **kwargs):
+        """CmdDown(self) -> bool"""
+        return _grid.GridRangeSelectEvent_CmdDown(*args, **kwargs)

 
 

-class GridRangeSelectEventPtr(GridRangeSelectEvent):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridRangeSelectEvent
-_grid.GridRangeSelectEvent_swigregister(GridRangeSelectEventPtr)
+GridRangeSelectEvent_swigregister = _grid.GridRangeSelectEvent_swigregister
+GridRangeSelectEvent_swigregister(GridRangeSelectEvent)

 
 

-class GridEditorCreatedEvent(core.CommandEvent):
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxGridEditorCreatedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
+class GridEditorCreatedEvent(_core.CommandEvent):
+    """Proxy of C++ GridEditorCreatedEvent 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__(int id, wxEventType type, Object obj, int row, int col, 
+        __init__(self, int id, wxEventType type, Object obj, int row, int col, 

             Control ctrl) -> GridEditorCreatedEvent
         """
             Control ctrl) -> GridEditorCreatedEvent
         """

-        newobj = _grid.new_GridEditorCreatedEvent(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
+        _grid.GridEditorCreatedEvent_swiginit(self,_grid.new_GridEditorCreatedEvent(*args, **kwargs))

     def GetRow(*args, **kwargs):
     def GetRow(*args, **kwargs):

-        """GetRow() -> int"""
+        """GetRow(self) -> int"""

         return _grid.GridEditorCreatedEvent_GetRow(*args, **kwargs)
 
     def GetCol(*args, **kwargs):
         return _grid.GridEditorCreatedEvent_GetRow(*args, **kwargs)
 
     def GetCol(*args, **kwargs):

-        """GetCol() -> int"""
+        """GetCol(self) -> int"""

         return _grid.GridEditorCreatedEvent_GetCol(*args, **kwargs)
 
     def GetControl(*args, **kwargs):
         return _grid.GridEditorCreatedEvent_GetCol(*args, **kwargs)
 
     def GetControl(*args, **kwargs):

-        """GetControl() -> Control"""
+        """GetControl(self) -> Control"""

         return _grid.GridEditorCreatedEvent_GetControl(*args, **kwargs)
 
     def SetRow(*args, **kwargs):
         return _grid.GridEditorCreatedEvent_GetControl(*args, **kwargs)
 
     def SetRow(*args, **kwargs):

-        """SetRow(int row)"""
+        """SetRow(self, int row)"""

         return _grid.GridEditorCreatedEvent_SetRow(*args, **kwargs)
 
     def SetCol(*args, **kwargs):
         return _grid.GridEditorCreatedEvent_SetRow(*args, **kwargs)
 
     def SetCol(*args, **kwargs):

-        """SetCol(int col)"""
+        """SetCol(self, int col)"""

         return _grid.GridEditorCreatedEvent_SetCol(*args, **kwargs)
 
     def SetControl(*args, **kwargs):
         return _grid.GridEditorCreatedEvent_SetCol(*args, **kwargs)
 
     def SetControl(*args, **kwargs):

-        """SetControl(Control ctrl)"""
+        """SetControl(self, Control ctrl)"""

         return _grid.GridEditorCreatedEvent_SetControl(*args, **kwargs)
 
         return _grid.GridEditorCreatedEvent_SetControl(*args, **kwargs)
 

-
-class GridEditorCreatedEventPtr(GridEditorCreatedEvent):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = GridEditorCreatedEvent
-_grid.GridEditorCreatedEvent_swigregister(GridEditorCreatedEventPtr)
+GridEditorCreatedEvent_swigregister = _grid.GridEditorCreatedEvent_swigregister
+GridEditorCreatedEvent_swigregister(GridEditorCreatedEvent)

 
 wxEVT_GRID_CELL_LEFT_CLICK = _grid.wxEVT_GRID_CELL_LEFT_CLICK
 wxEVT_GRID_CELL_RIGHT_CLICK = _grid.wxEVT_GRID_CELL_RIGHT_CLICK
 
 wxEVT_GRID_CELL_LEFT_CLICK = _grid.wxEVT_GRID_CELL_LEFT_CLICK
 wxEVT_GRID_CELL_RIGHT_CLICK = _grid.wxEVT_GRID_CELL_RIGHT_CLICK


@@ -2215,6 +2202,7 @@ wxEVT_GRID_SELECT_CELL = _grid.wxEVT_GRID_SELECT_CELL
 wxEVT_GRID_EDITOR_SHOWN = _grid.wxEVT_GRID_EDITOR_SHOWN
 wxEVT_GRID_EDITOR_HIDDEN = _grid.wxEVT_GRID_EDITOR_HIDDEN
 wxEVT_GRID_EDITOR_CREATED = _grid.wxEVT_GRID_EDITOR_CREATED
 wxEVT_GRID_EDITOR_SHOWN = _grid.wxEVT_GRID_EDITOR_SHOWN
 wxEVT_GRID_EDITOR_HIDDEN = _grid.wxEVT_GRID_EDITOR_HIDDEN
 wxEVT_GRID_EDITOR_CREATED = _grid.wxEVT_GRID_EDITOR_CREATED

+wxEVT_GRID_CELL_BEGIN_DRAG = _grid.wxEVT_GRID_CELL_BEGIN_DRAG

 EVT_GRID_CELL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK )
 EVT_GRID_CELL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK )
 EVT_GRID_CELL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK )
 EVT_GRID_CELL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK )
 EVT_GRID_CELL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK )
 EVT_GRID_CELL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK )


@@ -2231,5 +2219,28 @@ EVT_GRID_SELECT_CELL = wx.PyEventBinder( wxEVT_GRID_SELECT_CELL )
 EVT_GRID_EDITOR_SHOWN = wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN )
 EVT_GRID_EDITOR_HIDDEN = wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN )
 EVT_GRID_EDITOR_CREATED = wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED )
 EVT_GRID_EDITOR_SHOWN = wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN )
 EVT_GRID_EDITOR_HIDDEN = wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN )
 EVT_GRID_EDITOR_CREATED = wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED )

+EVT_GRID_CELL_BEGIN_DRAG = wx.PyEventBinder( wxEVT_GRID_CELL_BEGIN_DRAG )
+
+
+# The same as above but with the ability to specify an identifier
+EVT_GRID_CMD_CELL_LEFT_CLICK =     wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK,    1 )
+EVT_GRID_CMD_CELL_RIGHT_CLICK =    wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK,   1 )
+EVT_GRID_CMD_CELL_LEFT_DCLICK =    wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK,   1 )
+EVT_GRID_CMD_CELL_RIGHT_DCLICK =   wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK,  1 )
+EVT_GRID_CMD_LABEL_LEFT_CLICK =    wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK,   1 )
+EVT_GRID_CMD_LABEL_RIGHT_CLICK =   wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK,  1 )
+EVT_GRID_CMD_LABEL_LEFT_DCLICK =   wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK,  1 )
+EVT_GRID_CMD_LABEL_RIGHT_DCLICK =  wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK, 1 )
+EVT_GRID_CMD_ROW_SIZE =            wx.PyEventBinder( wxEVT_GRID_ROW_SIZE,           1 )
+EVT_GRID_CMD_COL_SIZE =            wx.PyEventBinder( wxEVT_GRID_COL_SIZE,           1 )
+EVT_GRID_CMD_RANGE_SELECT =        wx.PyEventBinder( wxEVT_GRID_RANGE_SELECT,       1 )
+EVT_GRID_CMD_CELL_CHANGE =         wx.PyEventBinder( wxEVT_GRID_CELL_CHANGE,        1 )
+EVT_GRID_CMD_SELECT_CELL =         wx.PyEventBinder( wxEVT_GRID_SELECT_CELL,        1 )
+EVT_GRID_CMD_EDITOR_SHOWN =        wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN,       1 )
+EVT_GRID_CMD_EDITOR_HIDDEN =       wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN,      1 )
+EVT_GRID_CMD_EDITOR_CREATED =      wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED,     1 )
+EVT_GRID_CMD_CELL_BEGIN_DRAG =     wx.PyEventBinder( wxEVT_GRID_CELL_BEGIN_DRAG,    1 )
+    
+