]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/src/msw/grid.cpp
added a call for invalidating the dc setup on mac explicitely (needed in case of...
[wxWidgets.git] / wxPython / src / msw / grid.cpp
index e7acb3f64cca42905b8cbae16c0a5dd93ef550b9..05c0c740b55952dcd166ffad6ee5edc1a77cabef 100644 (file)
@@ -3,7 +3,7 @@
  * 
  * This file was automatically generated by :
  * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Build 810)
+ * Version 1.1 (Build 883)
  * 
  * Portions Copyright (c) 1995-1998
  * The University of Utah and The Regents of the University of California.
@@ -41,6 +41,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 extern void SWIG_MakePtr(char *, void *, char *);
 extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
 extern char *SWIG_GetPtr(char *, void **, char *);
@@ -54,17 +55,17 @@ extern PyObject *SWIG_newvarlink(void);
 
 #define SWIG_name    "gridc"
 
-#include "helpers.h"
+#include "export.h"
 #include <wx/grid.h>
 
 static PyObject* l_output_helper(PyObject* target, PyObject* o) {
     PyObject*   o2;
-    if (!target) {
+    if (!target) {                   
         target = o;
-    } else if (target == Py_None) {
+    } else if (target == Py_None) {  
         Py_DECREF(Py_None);
         target = o;
-    } else {
+    } else {                         
         if (!PyList_Check(target)) {
             o2 = target;
             target = PyList_New(0);
@@ -81,23 +82,23 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
     PyObject*   o2;
     PyObject*   o3;
 
-    if (!target) {
+    if (!target) {                   
         target = o;
-    } else if (target == Py_None) {
+    } else if (target == Py_None) {  
         Py_DECREF(Py_None);
         target = o;
-    } else {
+    } else {                         
         if (!PyTuple_Check(target)) {
             o2 = target;
             target = PyTuple_New(1);
             PyTuple_SetItem(target, 0, o2);
         }
-        o3 = PyTuple_New(1);
-        PyTuple_SetItem(o3, 0, o);
+        o3 = PyTuple_New(1);            
+        PyTuple_SetItem(o3, 0, o);      
 
         o2 = target;
-        target = PySequence_Concat(o2, o3);
-        Py_DECREF(o2);
+        target = PySequence_Concat(o2, o3); 
+        Py_DECREF(o2);                      
         Py_DECREF(o3);
     }
     return target;
@@ -109,10 +110,10 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     wxGridCellAttr* CBNAME(int a, int b) {                              \
         wxGridCellAttr* rval = NULL;                                    \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
             PyObject* ro;                                               \
             wxGridCellAttr* ptr;                                        \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)", a, b)); \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", a, b)); \
             if (ro) {                                                   \
                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellAttr_p"))    \
                     rval = ptr;                                         \
@@ -133,11 +134,11 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                           \
     void CBNAME(wxGridCellAttr *attr, int a, int b) {                   \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(                                      \
-                Py_BuildValue("(Oii)",                                  \
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr"),    \
-                              a, b));                                   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b));   \
+            Py_DECREF(obj);                                             \
+        }                                                               \
         else                                                            \
             PCLASS::CBNAME(attr, a, b);                                 \
         wxPySaveThread(doSave);                                         \
@@ -151,11 +152,11 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__GCAINT(PCLASS, CBNAME)                              \
     void CBNAME(wxGridCellAttr *attr, int val) {                        \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(                                      \
-                Py_BuildValue("(Oi)",                                   \
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr"),    \
-                              val));                                    \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val));     \
+            Py_DECREF(obj);                                             \
+        }                                                               \
         else                                                            \
             PCLASS::CBNAME(attr, val);                                  \
         wxPySaveThread(doSave);                                         \
@@ -170,8 +171,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     int  CBNAME() {                                                     \
         bool doSave = wxPyRestoreThread();                              \
         int rval = 0;                                                   \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("()"));          \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));          \
         wxPySaveThread(doSave);                                         \
         return rval;                                                    \
     }
@@ -182,8 +183,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     bool CBNAME(int a, int b) {                                         \
         bool doSave = wxPyRestoreThread();                              \
         bool rval = 0;                                                  \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)",a,b));    \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \
         wxPySaveThread(doSave);                                         \
         return rval;                                                    \
     }
@@ -194,12 +195,13 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     wxString CBNAME(int a, int b) {                                     \
         bool doSave = wxPyRestoreThread();                              \
         wxString rval;                                                  \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
             PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",a,b));   \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));   \
             if (ro) {                                                   \
-                rval = PyString_AsString(PyObject_Str(ro));             \
-                Py_DECREF(ro);                                          \
+                PyObject* str = PyObject_Str(ro);                       \
+                rval = PyString_AsString(str);                          \
+                Py_DECREF(ro);  Py_DECREF(str);                         \
             }                                                           \
         }                                                               \
         wxPySaveThread(doSave);                                         \
@@ -211,8 +213,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__INTINTSTRING_pure(CBNAME)                           \
     void CBNAME(int a, int b, const wxString& c) {                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iis)",a,b,c.c_str()));    \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));    \
         wxPySaveThread(doSave);                                         \
     }
 
@@ -221,12 +223,13 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     wxString CBNAME(int a, int b) {                                     \
         bool doSave = wxPyRestoreThread();                              \
         wxString rval;                                                  \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
             PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",a,b));   \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));   \
             if (ro) {                                                   \
-                rval = PyString_AsString(PyObject_Str(ro));             \
-                Py_DECREF(ro);                                          \
+                PyObject* str = PyObject_Str(ro);                       \
+                rval = PyString_AsString(str);                          \
+                Py_DECREF(ro);  Py_DECREF(str);                         \
             }                                                           \
         } else                                                          \
             rval = PCLASS::CBNAME(a, b);                                \
@@ -243,8 +246,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     bool CBNAME(int a, int b, const wxString& c)  {                     \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(iis)", a,b,c.c_str()));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)", a,b,c.c_str()));   \
         else                                                            \
             rval = PCLASS::CBNAME(a,b,c);                               \
         wxPySaveThread(doSave);                                         \
@@ -261,8 +264,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     long CBNAME(int a, int b)  {                                        \
         long rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)", a,b));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));   \
         else                                                            \
             rval = PCLASS::CBNAME(a,b);                                 \
         wxPySaveThread(doSave);                                         \
@@ -278,8 +281,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     bool CBNAME(int a, int b)  {                                        \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)", a,b));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));   \
         else                                                            \
             rval = PCLASS::CBNAME(a,b);                                 \
         wxPySaveThread(doSave);                                         \
@@ -295,12 +298,13 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     double CBNAME(int a, int b) {                                       \
         bool doSave = wxPyRestoreThread();                              \
         double rval;                                                    \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
             PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",a,b));   \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));   \
             if (ro) {                                                   \
-                rval = PyFloat_AsDouble(PyObject_Str(ro));              \
-                Py_DECREF(ro);                                          \
+                PyObject* str = PyObject_Str(ro);                       \
+                rval = PyFloat_AsDouble(str);                           \
+                Py_DECREF(ro);   Py_DECREF(str);                        \
             }                                                           \
         } else                                                          \
             rval = PCLASS::CBNAME(a, b);                                \
@@ -316,8 +320,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__(PCLASS, CBNAME)                                    \
     void CBNAME()  {                                                    \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("()"));                 \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                 \
         else                                                            \
             PCLASS::CBNAME();                                           \
         wxPySaveThread(doSave);                                         \
@@ -333,8 +337,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     bool CBNAME(size_t a, size_t b)  {                                  \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)", a,b));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));   \
         else                                                            \
             rval = PCLASS::CBNAME(a,b);                                 \
         wxPySaveThread(doSave);                                         \
@@ -350,8 +354,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     bool CBNAME(size_t a)  {                                            \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(i)", a));      \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));      \
         else                                                            \
             rval = PCLASS::CBNAME(a);                                   \
         wxPySaveThread(doSave);                                         \
@@ -367,12 +371,13 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     wxString CBNAME(int a) {                                            \
         bool doSave = wxPyRestoreThread();                              \
         wxString rval;                                                  \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
             PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(i)",a));      \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a));      \
             if (ro) {                                                   \
-                rval = PyString_AsString(PyObject_Str(ro));             \
-                Py_DECREF(ro);                                          \
+                PyObject* str = PyObject_Str(ro);                       \
+                rval = PyString_AsString(str);                          \
+                Py_DECREF(ro);   Py_DECREF(str);                        \
             }                                                           \
         } else                                                          \
             rval = PCLASS::CBNAME(a);                                   \
@@ -388,8 +393,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                           \
     void CBNAME(int a, const wxString& c)  {                            \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(is)", a,c.c_str()));  \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(is)", a,c.c_str()));  \
         else                                                            \
             PCLASS::CBNAME(a,c);                                        \
         wxPySaveThread(doSave);                                         \
@@ -405,8 +410,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
     bool CBNAME()  {                                                    \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("()"));          \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));          \
         else                                                            \
             rval = PCLASS::CBNAME();                                    \
         wxPySaveThread(doSave);                                         \
@@ -421,8 +426,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                            \
     void CBNAME(size_t a, int b)  {                                     \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(ii)", a,b));          \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));          \
         else                                                            \
             PCLASS::CBNAME(a,b);                                        \
         wxPySaveThread(doSave);                                         \
@@ -437,8 +442,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                          \
     void CBNAME(int a, int b, long c)  {                                \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iii)", a,b,c));       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));       \
         else                                                            \
             PCLASS::CBNAME(a,b,c);                                      \
         wxPySaveThread(doSave);                                         \
@@ -453,8 +458,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                        \
     void CBNAME(int a, int b, double c)  {                              \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iif)", a,b,c));       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c));       \
         else                                                            \
             PCLASS::CBNAME(a,b,c);                                      \
         wxPySaveThread(doSave);                                         \
@@ -468,8 +473,8 @@ static char* wxStringErrorMsg = "string type is required for parameter";
 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                          \
     void CBNAME(int a, int b, bool c)  {                                \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iii)", a,b,c));       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));       \
         else                                                            \
             PCLASS::CBNAME(a,b,c);                                      \
         wxPySaveThread(doSave);                                         \
@@ -492,13 +497,13 @@ public:
               wxDC& dc, const wxRect& rect,
               int row, int col, bool isSelected) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Draw")) {
-            m_myInst.callCallback(
+        if (wxPyCBH_findCallback(m_myInst, "Draw")) {
+            wxPyCBH_callCallback(m_myInst,
                 Py_BuildValue("(OOOOiii)",
-                              wxPyConstructObject((void*)&grid, "wxGrid"),
-                              wxPyConstructObject((void*)&attr, "wxGridCellAttr"),
-                              wxPyConstructObject((void*)&dc,   "wxDC"),
-                              wxPyConstructObject((void*)&rect, "wxRect"),
+                              wxPyConstructObject((void*)&grid, "wxGrid", 0),
+                              wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
+                              wxPyConstructObject((void*)&dc,   "wxDC", 0),
+                              wxPyConstructObject((void*)&rect, "wxRect", 0),
                               row, col, isSelected));
         }
         wxPySaveThread(doSave);
@@ -508,14 +513,14 @@ public:
                        int row, int col) {
         wxSize rval;
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("GetBestSize")) {
+        if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
             PyObject* ro;
             wxSize*   ptr;
-            ro = m_myInst.callCallbackObj(
+            ro = wxPyCBH_callCallbackObj(m_myInst,
                 Py_BuildValue("(OOOii)",
-                              wxPyConstructObject((void*)&grid, "wxGrid"),
-                              wxPyConstructObject((void*)&attr, "wxGridCellAttr"),
-                              wxPyConstructObject((void*)&dc,   "wxDC"),
+                              wxPyConstructObject((void*)&grid, "wxGrid", 0),
+                              wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
+                              wxPyConstructObject((void*)&dc,   "wxDC", 0),
                               row, col));
             if (ro) {
                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))
@@ -531,10 +536,10 @@ public:
     wxGridCellRenderer *Clone() const {
         wxGridCellRenderer* rval = NULL;
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Clone")) {
+        if (wxPyCBH_findCallback(m_myInst, "Clone")) {
             PyObject* ro;
             wxGridCellRenderer* ptr;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
             if (ro) {
                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellRenderer_p"))
                     rval = ptr;
@@ -560,12 +565,12 @@ public:
 
     void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Create")) {
-            m_myInst.callCallback(
+        if (wxPyCBH_findCallback(m_myInst, "Create")) {
+            wxPyCBH_callCallback(m_myInst,
                 Py_BuildValue("(OiO)",
-                              wxPyConstructObject((void*)parent, "wxWindow"),
+                              wxPyConstructObject((void*)parent, "wxWindow", 0),
                               id,
-                              wxPyConstructObject((void*)evtHandler, "wxEvtHandler")));
+                              wxPyConstructObject((void*)evtHandler, "wxEvtHandler", 0)));
         }
         wxPySaveThread(doSave);
     }
@@ -573,10 +578,10 @@ public:
 
     void BeginEdit(int row, int col, wxGrid* grid) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("BeginEdit")) {
-            m_myInst.callCallback(
+        if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
+            wxPyCBH_callCallback(m_myInst,
                 Py_BuildValue("(iiO)", row, col,
-                              wxPyConstructObject((void*)grid, "wxGrid")));
+                              wxPyConstructObject((void*)grid, "wxGrid", 0)));
         }
         wxPySaveThread(doSave);
     }
@@ -585,10 +590,10 @@ public:
     bool EndEdit(int row, int col, wxGrid* grid) {
         bool rv = FALSE;
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("EndEdit")) {
-            rv = m_myInst.callCallback(
+        if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
+            rv = wxPyCBH_callCallback(m_myInst,
                 Py_BuildValue("(iiO)", row, col,
-                              wxPyConstructObject((void*)grid, "wxGrid")));
+                              wxPyConstructObject((void*)grid, "wxGrid", 0)));
         }
         wxPySaveThread(doSave);
         return rv;
@@ -598,10 +603,10 @@ public:
     wxGridCellEditor*Clone() const {
         wxGridCellEditor* rval = NULL;
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Clone")) {
+        if (wxPyCBH_findCallback(m_myInst, "Clone")) {
             PyObject* ro;
             wxGridCellEditor* ptr;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
             if (ro) {
                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellEditor_p"))
                     rval = ptr;
@@ -615,10 +620,10 @@ public:
 
     void Show(bool show, wxGridCellAttr *attr) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Show"))
-            m_myInst.callCallback(
+        if (wxPyCBH_findCallback(m_myInst, "Show"))
+            wxPyCBH_callCallback(m_myInst,
                 Py_BuildValue("(iO)", show,
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr")));
+                              wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
         else
             wxGridCellEditor::Show(show, attr);
         wxPySaveThread(doSave);
@@ -630,11 +635,11 @@ public:
 
     void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("PaintBackground"))
-            m_myInst.callCallback(
+        if (wxPyCBH_findCallback(m_myInst, "PaintBackground"))
+            wxPyCBH_callCallback(m_myInst,
                 Py_BuildValue("(OO)",
-                              wxPyConstructObject((void*)&rectCell, "wxRect"),
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr")));
+                              wxPyConstructObject((void*)&rectCell, "wxRect", 0),
+                              wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
         else
             wxGridCellEditor::PaintBackground(rectCell, attr);
         wxPySaveThread(doSave);
@@ -709,16 +714,17 @@ public:
     PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
 
 
-
     wxString GetValue(int row, int col) {
         bool doSave = wxPyRestoreThread();
         wxString rval;
-        if (m_myInst.findCallback("GetValue")) {
+        if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
             PyObject* ro;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",row,col));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
             if (ro) {
-                rval = PyString_AsString(PyObject_Str(ro));
+                PyObject* str = PyObject_Str(ro);
+                rval = PyString_AsString(str);
                 Py_DECREF(ro);
+                Py_DECREF(str);
             }
         }
         wxPySaveThread(doSave);
@@ -727,8 +733,8 @@ public:
 
     void SetValue(int row, int col, const wxString& val) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("SetValue"))
-            m_myInst.callCallback(Py_BuildValue("(iis)",row,col,val.c_str()));
+        if (wxPyCBH_findCallback(m_myInst, "SetValue"))
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",row,col,val.c_str()));
         wxPySaveThread(doSave);
     }
 
@@ -738,10 +744,10 @@ public:
     long GetValueAsLong( int row, int col ) {
         long rval = 0;
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("GetValue")) {
+        if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
             PyObject* ro;
             PyObject* num;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)", row, col));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
             if (ro && PyNumber_Check(ro)) {
                 num = PyNumber_Int(ro);
                 if (num) {
@@ -758,10 +764,10 @@ public:
     double GetValueAsDouble( int row, int col ) {
         double rval = 0.0;
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("GetValue")) {
+        if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
             PyObject* ro;
             PyObject* num;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)", row, col));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
             if (ro && PyNumber_Check(ro)) {
                 num = PyNumber_Float(ro);
                 if (num) {
@@ -781,16 +787,16 @@ public:
 
     void SetValueAsLong( int row, int col, long value ) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("SetValue")) {
-            m_myInst.callCallback(Py_BuildValue("(iii)", row, col, value));
+        if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
         }
         wxPySaveThread(doSave);
     }
 
     void SetValueAsDouble( int row, int col, double value ) {
         bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("SetValue")) {
-            m_myInst.callCallback(Py_BuildValue("(iid)", row, col, value));
+        if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
         }
         wxPySaveThread(doSave);
     }
@@ -880,11 +886,22 @@ static PyObject *_wrap_wxGridCellRenderer_SetParameters(PyObject *self, PyObject
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -1203,11 +1220,22 @@ static PyObject *_wrap_wxPyGridCellRenderer_base_SetParameters(PyObject *self, P
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -1600,11 +1628,22 @@ static PyObject *_wrap_wxGridCellEditor_SetParameters(PyObject *self, PyObject *
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -2325,6 +2364,42 @@ static PyObject *_wrap_wxPyGridCellEditor_base_PaintBackground(PyObject *self, P
     return _resultobj;
 }
 
+#define wxPyGridCellEditor_base_IsAcceptedKey(_swigobj,_swigarg0)  (_swigobj->base_IsAcceptedKey(_swigarg0))
+static PyObject *_wrap_wxPyGridCellEditor_base_IsAcceptedKey(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyGridCellEditor * _arg0;
+    wxKeyEvent * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","event", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_IsAcceptedKey",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_IsAcceptedKey. Expected _wxPyGridCellEditor_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellEditor_base_IsAcceptedKey. Expected _wxKeyEvent_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        wxPyGridCellEditor_base_IsAcceptedKey(_arg0,*_arg1);
+
+    wxPy_END_ALLOW_THREADS;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
 #define wxPyGridCellEditor_base_StartingKey(_swigobj,_swigarg0)  (_swigobj->base_StartingKey(_swigarg0))
 static PyObject *_wrap_wxPyGridCellEditor_base_StartingKey(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject * _resultobj;
@@ -2471,11 +2546,22 @@ static PyObject *_wrap_wxPyGridCellEditor_base_SetParameters(PyObject *self, PyO
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -4243,11 +4329,22 @@ static PyObject *_wrap_wxGridTableBase_SetValue(PyObject *self, PyObject *args,
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg3 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj3)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3));
+    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -4320,11 +4417,22 @@ static PyObject *_wrap_wxGridTableBase_CanGetValueAs(PyObject *self, PyObject *a
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg3 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj3)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3));
+    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -4362,11 +4470,22 @@ static PyObject *_wrap_wxGridTableBase_CanSetValueAs(PyObject *self, PyObject *a
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg3 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj3)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3));
+    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -4846,11 +4965,22 @@ static PyObject *_wrap_wxGridTableBase_SetRowLabelValue(PyObject *self, PyObject
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -4887,11 +5017,22 @@ static PyObject *_wrap_wxGridTableBase_SetColLabelValue(PyObject *self, PyObject
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -5236,11 +5377,22 @@ static PyObject *_wrap_wxPyGridTableBase_base_CanGetValueAs(PyObject *self, PyOb
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg3 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj3)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3));
+    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -5278,11 +5430,22 @@ static PyObject *_wrap_wxPyGridTableBase_base_CanSetValueAs(PyObject *self, PyOb
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg3 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj3)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3));
+    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -5583,11 +5746,22 @@ static PyObject *_wrap_wxPyGridTableBase_base_SetRowLabelValue(PyObject *self, P
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -5624,11 +5798,22 @@ static PyObject *_wrap_wxPyGridTableBase_base_SetColLabelValue(PyObject *self, P
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -7023,11 +7208,22 @@ static PyObject *_wrap_wxGrid_DrawTextRectangle(PyObject *self, PyObject *args,
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     _arg3 = &temp;
@@ -7070,11 +7266,22 @@ static PyObject *_wrap_wxGrid_StringToLines(PyObject *self, PyObject *args, PyOb
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
     if (_argo2) {
         if (_argo2 == Py_None) { _arg2 = NULL; }
@@ -8821,11 +9028,22 @@ static PyObject *_wrap_wxGrid_SetRowLabelValue(PyObject *self, PyObject *args, P
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -8862,11 +9080,22 @@ static PyObject *_wrap_wxGrid_SetColLabelValue(PyObject *self, PyObject *args, P
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -9385,11 +9614,22 @@ static PyObject *_wrap_wxGrid_SetColFormatCustom(PyObject *self, PyObject *args,
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg2 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj2)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -10793,11 +11033,22 @@ static PyObject *_wrap_wxGrid_SetCellValue(PyObject *self, PyObject *args, PyObj
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg3 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj3)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3));
+    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -11277,11 +11528,22 @@ static PyObject *_wrap_wxGrid_RegisterDataType(PyObject *self, PyObject *args, P
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
     if (_argo2) {
         if (_argo2 == Py_None) { _arg2 = NULL; }
@@ -11405,11 +11667,22 @@ static PyObject *_wrap_wxGrid_GetDefaultEditorForType(PyObject *self, PyObject *
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -11452,11 +11725,22 @@ static PyObject *_wrap_wxGrid_GetDefaultRendererForType(PyObject *self, PyObject
         }
     }
 {
+#if PYTHON_API_VERSION >= 1009
+    char* tmpPtr; int tmpSize;
+    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
+        PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
+        return NULL;
+    }
+    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+        return NULL;
+    _arg1 = new wxString(tmpPtr, tmpSize);
+#else
     if (!PyString_Check(_obj1)) {
         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
         return NULL;
     }
-    _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1));
+    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
+#endif
 }
 {
     wxPy_BEGIN_ALLOW_THREADS;
@@ -12743,6 +13027,7 @@ static PyMethodDef gridcMethods[] = {
         { "wxPyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_wxPyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS },
         { "wxPyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS },
         { "wxPyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS },
+        { "wxPyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS },
         { "wxPyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_wxPyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS },
         { "wxPyGridCellEditor_base_Show", (PyCFunction) _wrap_wxPyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS },
         { "wxPyGridCellEditor_base_SetSize", (PyCFunction) _wrap_wxPyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS },
@@ -12889,7 +13174,6 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
     { "_class_wxRealPoint","_wxRealPoint",0},
     { "_wxNavigationKeyEvent","_class_wxNavigationKeyEvent",0},
     { "_class_wxGridRangeSelectEvent","_wxGridRangeSelectEvent",0},
-    { "_wxPrinterDC","_class_wxPrinterDC",0},
     { "_wxWindowCreateEvent","_class_wxWindowCreateEvent",0},
     { "_class_wxMenuItem","_wxMenuItem",0},
     { "_class_wxPaintEvent","_wxPaintEvent",0},
@@ -13186,7 +13470,6 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
     { "_wxButton","_class_wxButton",0},
     { "_wxSize","_class_wxSize",0},
     { "_wxRegionIterator","_class_wxRegionIterator",0},
-    { "_class_wxPrinterDC","_wxPrinterDC",0},
     { "_class_wxPyTextDataObject","_wxPyTextDataObject",0},
     { "_class_wxPaintDC","_wxPaintDC",0},
     { "_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0},
@@ -13341,6 +13624,9 @@ SWIGEXPORT(void) initgridc() {
         PyDict_SetItemString(d,"wxEVT_GRID_SELECT_CELL", PyInt_FromLong((long) wxEVT_GRID_SELECT_CELL));
         PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_SHOWN));
         PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_HIDDEN));
+
+    wxClassInfo::CleanUpClasses();
+    wxClassInfo::InitializeClasses();
         PyDict_SetItemString(d,"wxGrid_wxGridSelectCells", PyInt_FromLong((long) wxGrid::wxGridSelectCells));
         PyDict_SetItemString(d,"wxGrid_wxGridSelectRows", PyInt_FromLong((long) wxGrid::wxGridSelectRows));
         PyDict_SetItemString(d,"wxGrid_wxGridSelectColumns", PyInt_FromLong((long) wxGrid::wxGridSelectColumns));