Some improvements and additions for wxListCtrl and logging

[wxWidgets.git] / wxPython / src / msw / grid.cpp
diff --git a/wxPython/src/msw/grid.cpp b/wxPython/src/msw/grid.cpp

index b65d674a27a9d763bb394af61e77909be86fc88a..de3859039a5b1b0123c2023e1162986237b3c67a 100644 (file)
--- a/wxPython/src/msw/grid.cpp
+++ b/wxPython/src/msw/grid.cpp
@@ -55,7 +55,7 @@ extern PyObject *SWIG_newvarlink(void);
  
  #define SWIG_name    "gridc"
  
  
  #define SWIG_name    "gridc"
  
-#include "export.h"
+#include "wxPython.h"
  #include <wx/grid.h>
  #include <wx/generic/gridctrl.h>
  
  #include <wx/grid.h>
  #include <wx/generic/gridctrl.h>
  
@@ -86,17 +86,49 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
      return target;
  }
  
      return target;
  }
  
-#if PYTHON_API_VERSION >= 1009
-    static char* wxStringErrorMsg = "String or Unicode type required";
-#else
-    static char* wxStringErrorMsg = "string type is required for parameter";
-#endif
+    // Put some wx default wxChar* values into wxStrings.
+    DECLARE_DEF_STRING(PanelNameStr);
+    DECLARE_DEF_STRING2(DateTimeFormatStr, wxT("%c"));
+    static const wxString wxPyEmptyString(wxT(""));
+
+
+#define wxPyMake_TEMPLATE(TYPE) \
+PyObject* wxPyMake_##TYPE(TYPE* source) { \
+    PyObject* target = NULL; \
+    if (source) { \
+        /* Check if there is already a pointer to a Python object in the \
+           OOR data that we can use. */ \
+        wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
+        if (data) { \
+            target = data->m_obj; \
+            Py_INCREF(target); \
+        } \
+        /* Otherwise make a new wrapper for it the old fashioned way and \
+           give it the OOR treatment */ \
+        if (! target) { \
+            target = wxPyConstructObject(source, #TYPE, FALSE); \
+            if (target) \
+                source->SetClientObject(new wxPyOORClientData(target)); \
+        } \
+    } else {  /* source was NULL so return None. */ \
+        Py_INCREF(Py_None); target = Py_None; \
+    } \
+    return target; \
+} \
+
+
+wxPyMake_TEMPLATE(wxGridCellRenderer)
+wxPyMake_TEMPLATE(wxGridCellEditor)
+wxPyMake_TEMPLATE(wxGridCellAttr)
+wxPyMake_TEMPLATE(wxGridCellAttrProvider)
+wxPyMake_TEMPLATE(wxGridTableBase)
+
  
  #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME)                               \
      wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) {        \
          wxGridCellAttr* rval = NULL;                                            \
          bool found;                                                             \
  
  #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME)                               \
      wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) {        \
          wxGridCellAttr* rval = NULL;                                            \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              wxGridCellAttr* ptr;                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              wxGridCellAttr* ptr;                                                \
@@ -107,7 +139,7 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b, c);                                     \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b, c);                                     \
          return rval;                                                            \
@@ -120,14 +152,14 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                                   \
      void CBNAME(wxGridCellAttr *attr, int a, int b) {                           \
  
  #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                                   \
      void CBNAME(wxGridCellAttr *attr, int a, int b) {                           \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          bool found;                                                             \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
          bool found;                                                             \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
-            PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b));   \
+            PyObject* obj = wxPyMake_wxGridCellAttr(attr);                      \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b));  \
              Py_DECREF(obj);                                                     \
          }                                                                       \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(attr, a, b);                                         \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(attr, a, b);                                         \
      }                                                                           \
@@ -139,14 +171,14 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK__GCAINT(PCLASS, CBNAME)                                      \
      void CBNAME(wxGridCellAttr *attr, int val) {                                \
  
  #define PYCALLBACK__GCAINT(PCLASS, CBNAME)                                      \
      void CBNAME(wxGridCellAttr *attr, int val) {                                \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          bool found;                                                             \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
          bool found;                                                             \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
-            PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
+            PyObject* obj = wxPyMake_wxGridCellAttr(attr);                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val));    \
              Py_DECREF(obj);                                                     \
          }                                                                       \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val));    \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(attr, val);                                          \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(attr, val);                                          \
      }                                                                           \
@@ -158,11 +190,11 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK_INT__pure(CBNAME)                                            \
      int  CBNAME() {                                                             \
  
  #define PYCALLBACK_INT__pure(CBNAME)                                            \
      int  CBNAME() {                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          int rval = 0;                                                           \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
          int rval = 0;                                                           \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          return rval;                                                            \
      }
  
          return rval;                                                            \
      }
  
@@ -170,59 +202,58 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK_BOOL_INTINT_pure(CBNAME)                                     \
      bool CBNAME(int a, int b) {                                                 \
  
  #define PYCALLBACK_BOOL_INTINT_pure(CBNAME)                                     \
      bool CBNAME(int a, int b) {                                                 \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          bool rval = 0;                                                          \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));   \
          bool rval = 0;                                                          \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));   \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          return rval;                                                            \
      }
  
  
          return rval;                                                            \
      }
  
  
-
  #define PYCALLBACK_STRING_INTINT_pure(CBNAME)                                   \
      wxString CBNAME(int a, int b) {                                             \
  #define PYCALLBACK_STRING_INTINT_pure(CBNAME)                                   \
      wxString CBNAME(int a, int b) {                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          wxString rval;                                                          \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
              if (ro) {                                                           \
          wxString rval;                                                          \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
              if (ro) {                                                           \
-                PyObject* str = PyObject_Str(ro);                               \
-                rval = PyString_AsString(str);                                  \
-                Py_DECREF(ro);  Py_DECREF(str);                                 \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          return rval;                                                            \
      }
  
  
          return rval;                                                            \
      }
  
  
-
  #define PYCALLBACK__INTINTSTRING_pure(CBNAME)                                   \
      void CBNAME(int a, int b, const wxString& c) {                              \
  #define PYCALLBACK__INTINTSTRING_pure(CBNAME)                                   \
      void CBNAME(int a, int b, const wxString& c) {                              \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
-        wxPyEndBlockThreads(state);                                             \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* s = wx2PyString(c);                                       \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
+            Py_DECREF(s);                                                       \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
      }
  
  
  #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME)                                \
      wxString CBNAME(int a, int b) {                                             \
          bool found;                                                             \
      }
  
  
  #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME)                                \
      wxString CBNAME(int a, int b) {                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          wxString rval;                                                          \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
              if (ro) {                                                           \
          wxString rval;                                                          \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
              if (ro) {                                                           \
-                PyObject* str = PyObject_Str(ro);                               \
-                rval = PyString_AsString(str);                                  \
-                Py_DECREF(ro);  Py_DECREF(str);                                 \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b);                                        \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b);                                        \
          return rval;                                                            \
@@ -232,15 +263,17 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
      }
  
  
      }
  
  
-
  #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME)                            \
      bool CBNAME(int a, int b, const wxString& c)  {                             \
  #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME)                            \
      bool CBNAME(int a, int b, const wxString& c)  {                             \
-        bool rval;                                                              \
+        bool rval = 0;                                                          \
          bool found;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
-        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)", a,b,c.c_str()));\
-        wxPyEndBlockThreads(state);                                             \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* s = wx2PyString(c);                                       \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
+            Py_DECREF(s);                                                       \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b,c);                                       \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b,c);                                       \
          return rval;                                                            \
@@ -256,10 +289,10 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
      long CBNAME(int a, int b)  {                                                \
          long rval;                                                              \
          bool found;                                                             \
      long CBNAME(int a, int b)  {                                                \
          long rval;                                                              \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b);                                         \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b);                                         \
          return rval;                                                            \
@@ -272,12 +305,12 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                                  \
      bool CBNAME(int a, int b)  {                                                \
  
  #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                                  \
      bool CBNAME(int a, int b)  {                                                \
-        bool rval;                                                              \
+        bool rval = 0;                                                          \
          bool found;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b);                                         \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b);                                         \
          return rval;                                                            \
@@ -291,7 +324,7 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME)                                \
      double CBNAME(int a, int b) {                                               \
          bool found;                                                             \
  #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME)                                \
      double CBNAME(int a, int b) {                                               \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          double rval;                                                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
          double rval;                                                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
@@ -302,7 +335,7 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
                  Py_DECREF(ro);   Py_DECREF(str);                                \
              }                                                                   \
          }                                                                       \
                  Py_DECREF(ro);   Py_DECREF(str);                                \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b);                                        \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b);                                        \
          return rval;                                                            \
@@ -316,10 +349,10 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  #define PYCALLBACK__(PCLASS, CBNAME)                                            \
      void CBNAME()  {                                                            \
          bool found;                                                             \
  #define PYCALLBACK__(PCLASS, CBNAME)                                            \
      void CBNAME()  {                                                            \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME();                                                   \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME();                                                   \
      }                                                                           \
@@ -332,12 +365,12 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME)                              \
      bool CBNAME(size_t a, size_t b)  {                                          \
  
  #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME)                              \
      bool CBNAME(size_t a, size_t b)  {                                          \
-        bool rval;                                                              \
+        bool rval = 0;                                                          \
          bool found;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b);                                         \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a,b);                                         \
          return rval;                                                            \
@@ -350,12 +383,12 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME)                                   \
      bool CBNAME(size_t a)  {                                                    \
  
  #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME)                                   \
      bool CBNAME(size_t a)  {                                                    \
-        bool rval;                                                              \
+        bool rval = 0;                                                          \
          bool found;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
@@ -365,22 +398,20 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
      }
  
  
      }
  
  
-
  #define PYCALLBACK_STRING_INT(PCLASS, CBNAME)                                   \
      wxString CBNAME(int a) {                                                    \
          bool found;                                                             \
  #define PYCALLBACK_STRING_INT(PCLASS, CBNAME)                                   \
      wxString CBNAME(int a) {                                                    \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          wxString rval;                                                          \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a));     \
              if (ro) {                                                           \
          wxString rval;                                                          \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a));     \
              if (ro) {                                                           \
-                PyObject* str = PyObject_Str(ro);                               \
-                rval = PyString_AsString(str);                                  \
-                Py_DECREF(ro);   Py_DECREF(str);                                \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
@@ -390,14 +421,16 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
      }
  
  
      }
  
  
-
  #define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                                   \
      void CBNAME(int a, const wxString& c)  {                                    \
          bool found;                                                             \
  #define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                                   \
      void CBNAME(int a, const wxString& c)  {                                    \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
-        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(is)", a,c.c_str())); \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* s = wx2PyString(c);                                       \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s));          \
+            Py_DECREF(s);                                                       \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(a,c);                                                \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a,c);                                                \
      }                                                                           \
@@ -410,12 +443,12 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  
  #define PYCALLBACK_BOOL_(PCLASS, CBNAME)                                        \
      bool CBNAME()  {                                                            \
  
  #define PYCALLBACK_BOOL_(PCLASS, CBNAME)                                        \
      bool CBNAME()  {                                                            \
-        bool rval;                                                              \
+        bool rval = 0;                                                          \
          bool found;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME();                                            \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME();                                            \
          return rval;                                                            \
@@ -429,10 +462,10 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  #define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                                    \
      void CBNAME(size_t a, int b)  {                                             \
          bool found;                                                             \
  #define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                                    \
      void CBNAME(size_t a, int b)  {                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));         \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));         \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b);                                                \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b);                                                \
      }                                                                           \
@@ -446,10 +479,10 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                                  \
      void CBNAME(int a, int b, long c)  {                                        \
          bool found;                                                             \
  #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                                  \
      void CBNAME(int a, int b, long c)  {                                        \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b,c);                                              \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b,c);                                              \
      }                                                                           \
@@ -463,10 +496,10 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                                \
      void CBNAME(int a, int b, double c)  {                                      \
          bool found;                                                             \
  #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                                \
      void CBNAME(int a, int b, double c)  {                                      \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c));      \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c));      \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b,c);                                              \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b,c);                                              \
      }                                                                           \
@@ -479,10 +512,10 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                                  \
      void CBNAME(int a, int b, bool c)  {                                        \
          bool found;                                                             \
  #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                                  \
      void CBNAME(int a, int b, bool c)  {                                        \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b,c);                                              \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a,b,c);                                              \
      }                                                                           \
@@ -503,46 +536,70 @@ public:
      void Draw(wxGrid& grid, wxGridCellAttr& attr,
                wxDC& dc, const wxRect& rect,
                int row, int col, bool isSelected) {
      void Draw(wxGrid& grid, wxGridCellAttr& attr,
                wxDC& dc, const wxRect& rect,
                int row, int col, bool isSelected) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "Draw")) {
          if (wxPyCBH_findCallback(m_myInst, "Draw")) {
-            wxPyCBH_callCallback(m_myInst,
-                Py_BuildValue("(OOOOiii)",
-                              wxPyConstructObject((void*)&grid, "wxGrid", 0),
-                              wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
-                              wxPyConstructObject((void*)&dc,   "wxDC", 0),
-                              wxPyConstructObject((void*)&rect, "wxRect", 0),
-                              row, col, isSelected));
+            PyObject* go = wxPyMake_wxObject(&grid);
+            PyObject* dco = wxPyMake_wxObject(&dc);
+            PyObject* ao = wxPyMake_wxGridCellAttr(&attr);
+            PyObject* ro = wxPyConstructObject((void*)&rect, "wxRect", 0);
+
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
+                                                         row, col, isSelected));
+            Py_DECREF(go);
+            Py_DECREF(ao);
+            Py_DECREF(dco);
+            Py_DECREF(ro);
          }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
      }
  
      wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
                         int row, int col) {
          wxSize rval;
      }
  
      wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
                         int row, int col) {
          wxSize rval;
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
              PyObject* ro;
              wxSize*   ptr;
          if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
              PyObject* ro;
              wxSize*   ptr;
-            ro = wxPyCBH_callCallbackObj(m_myInst,
-                Py_BuildValue("(OOOii)",
-                              wxPyConstructObject((void*)&grid, "wxGrid", 0),
-                              wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
-                              wxPyConstructObject((void*)&dc,   "wxDC", 0),
-                              row, col));
+            PyObject* go = wxPyMake_wxObject(&grid);
+            PyObject* dco = wxPyMake_wxObject(&dc);
+            PyObject* ao = wxPyMake_wxGridCellAttr(&attr);
+
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
+                                                                 go, ao, dco,
+                                                                 row, col));
+            Py_DECREF(go);
+            Py_DECREF(ao);
+            Py_DECREF(dco);
+
              if (ro) {
              if (ro) {
-                if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))
+                const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
+                if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p")) {
                      rval = *ptr;
                      rval = *ptr;
+                }
+                else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
+                    PyObject* o1 = PySequence_GetItem(ro, 0);
+                    PyObject* o2 = PySequence_GetItem(ro, 1);
+                    if (PyNumber_Check(o1) && PyNumber_Check(o2))
+                        rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
+                    else
+                        PyErr_SetString(PyExc_TypeError, errmsg);
+                    Py_DECREF(o1);
+                    Py_DECREF(o2);
+                }
+                else {
+                    PyErr_SetString(PyExc_TypeError, errmsg);
+                }
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
          return rval;
      }
  
  
      wxGridCellRenderer *Clone() const {
          wxGridCellRenderer* rval = NULL;
          return rval;
      }
  
  
      wxGridCellRenderer *Clone() const {
          wxGridCellRenderer* rval = NULL;
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "Clone")) {
              PyObject* ro;
              wxGridCellRenderer* ptr;
          if (wxPyCBH_findCallback(m_myInst, "Clone")) {
              PyObject* ro;
              wxGridCellRenderer* ptr;
@@ -553,7 +610,7 @@ public:
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
          return rval;
      }
  
          return rval;
      }
  
@@ -571,45 +628,46 @@ public:
      wxPyGridCellEditor() : wxGridCellEditor() {}
  
      void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
      wxPyGridCellEditor() : wxGridCellEditor() {}
  
      void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "Create")) {
          if (wxPyCBH_findCallback(m_myInst, "Create")) {
-            wxPyCBH_callCallback(m_myInst,
-                Py_BuildValue("(OiO)",
-                              wxPyConstructObject((void*)parent, "wxWindow", 0),
-                              id,
-                              wxPyConstructObject((void*)evtHandler, "wxEvtHandler", 0)));
+            PyObject* po = wxPyMake_wxObject(parent);
+            PyObject* eo = wxPyMake_wxObject(evtHandler);
+
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
+            Py_DECREF(po);
+            Py_DECREF(eo);
          }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
      }
  
  
      void BeginEdit(int row, int col, wxGrid* grid) {
      }
  
  
      void BeginEdit(int row, int col, wxGrid* grid) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
          if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
-            wxPyCBH_callCallback(m_myInst,
-                Py_BuildValue("(iiO)", row, col,
-                              wxPyConstructObject((void*)grid, "wxGrid", 0)));
+            PyObject* go = wxPyMake_wxObject(grid);
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
+            Py_DECREF(go);
          }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
      }
  
  
      bool EndEdit(int row, int col, wxGrid* grid) {
          bool rv = FALSE;
      }
  
  
      bool EndEdit(int row, int col, wxGrid* grid) {
          bool rv = FALSE;
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
          if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
-            rv = wxPyCBH_callCallback(m_myInst,
-                Py_BuildValue("(iiO)", row, col,
-                              wxPyConstructObject((void*)grid, "wxGrid", 0)));
+            PyObject* go = wxPyMake_wxObject(grid);
+            rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
+            Py_DECREF(go);
          }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
          return rv;
      }
  
  
      wxGridCellEditor*Clone() const {
          wxGridCellEditor* rval = NULL;
          return rv;
      }
  
  
      wxGridCellEditor*Clone() const {
          wxGridCellEditor* rval = NULL;
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "Clone")) {
              PyObject* ro;
              wxGridCellEditor* ptr;
          if (wxPyCBH_findCallback(m_myInst, "Clone")) {
              PyObject* ro;
              wxGridCellEditor* ptr;
@@ -620,19 +678,20 @@ public:
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
          return rval;
      }
  
  
      void Show(bool show, wxGridCellAttr *attr) {
          bool found;
          return rval;
      }
  
  
      void Show(bool show, wxGridCellAttr *attr) {
          bool found;
-        wxPyTState* state = wxPyBeginBlockThreads();
-        if ((found = wxPyCBH_findCallback(m_myInst, "Show")))
-            wxPyCBH_callCallback(m_myInst,
-                Py_BuildValue("(iO)", show,
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
-        wxPyEndBlockThreads(state);
+        wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
+            PyObject* ao = wxPyMake_wxGridCellAttr(attr);
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
+            Py_DECREF(ao);
+        }
+        wxPyEndBlockThreads();
          if (! found)
              wxGridCellEditor::Show(show, attr);
      }
          if (! found)
              wxGridCellEditor::Show(show, attr);
      }
@@ -642,14 +701,18 @@ public:
  
  
      void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
  
  
      void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
-        bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();
-        if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)")))
-            wxPyCBH_callCallback(m_myInst,
-                Py_BuildValue("(OO)",
-                              wxPyConstructObject((void*)&rectCell, "wxRect", 0),
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
-        wxPyEndBlockThreads(state);
+        bool found;
+        wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
+            PyObject* ao = wxPyMake_wxGridCellAttr(attr);
+            PyObject* ro = wxPyConstructObject((void*)&rectCell, "wxRect", 0);
+
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
+
+            Py_DECREF(ro);
+            Py_DECREF(ao);
+        }
+        wxPyEndBlockThreads();
          if (! found)
              wxGridCellEditor::PaintBackground(rectCell, attr);
      }
          if (! found)
              wxGridCellEditor::PaintBackground(rectCell, attr);
      }
@@ -724,27 +787,28 @@ public:
  
  
      wxString GetValue(int row, int col) {
  
  
      wxString GetValue(int row, int col) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          wxString rval;
          if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
              if (ro) {
          wxString rval;
          if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
              if (ro) {
-                PyObject* str = PyObject_Str(ro);
-                rval = PyString_AsString(str);
+                rval = Py2wxString(ro);
                  Py_DECREF(ro);
                  Py_DECREF(ro);
-                Py_DECREF(str);
              }
          }
              }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
          return rval;
      }
  
      void SetValue(int row, int col, const wxString& val) {
          return rval;
      }
  
      void SetValue(int row, int col, const wxString& val) {
-        wxPyTState* state = wxPyBeginBlockThreads();
-        if (wxPyCBH_findCallback(m_myInst, "SetValue"))
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",row,col,val.c_str()));
-        wxPyEndBlockThreads(state);
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
+            PyObject* s = wx2PyString(val);
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
+            Py_DECREF(s);
+       }
+        wxPyEndBlockThreads();
      }
  
  
      }
  
  
@@ -752,7 +816,7 @@ public:
      // the GetValue and SetValue python methods.
      long GetValueAsLong( int row, int col ) {
          long rval = 0;
      // the GetValue and SetValue python methods.
      long GetValueAsLong( int row, int col ) {
          long rval = 0;
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              PyObject* num;
          if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              PyObject* num;
@@ -766,13 +830,13 @@ public:
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
          return rval;
      }
  
      double GetValueAsDouble( int row, int col ) {
          double rval = 0.0;
          return rval;
      }
  
      double GetValueAsDouble( int row, int col ) {
          double rval = 0.0;
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              PyObject* num;
          if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              PyObject* num;
@@ -786,7 +850,7 @@ public:
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
          return rval;
      }
  
          return rval;
      }
  
@@ -795,19 +859,19 @@ public:
      }
  
      void SetValueAsLong( int row, int col, long value ) {
      }
  
      void SetValueAsLong( int row, int col, long value ) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
          }
          if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
      }
  
      void SetValueAsDouble( int row, int col, double value ) {
      }
  
      void SetValueAsDouble( int row, int col, double value ) {
-        wxPyTState* state = wxPyBeginBlockThreads();
+        wxPyBeginBlockThreads();
          if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
          }
          if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
          }
-        wxPyEndBlockThreads(state);
+        wxPyEndBlockThreads();
      }
  
      void SetValueAsBool( int row, int col, bool value ) {
      }
  
      void SetValueAsBool( int row, int col, bool value ) {
@@ -875,6 +939,41 @@ static PyObject *_wrap_wxGridNoCellRect_get() {
      return pyobj;
  }
  
      return pyobj;
  }
  
+static void  wxGridCellRenderer__setOORInfo(wxGridCellRenderer *self,PyObject * _self) {
+            self->SetClientObject(new wxPyOORClientData(_self));
+        }
+static PyObject *_wrap_wxGridCellRenderer__setOORInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxGridCellRenderer * _arg0;
+    PyObject * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _obj1 = 0;
+    char *_kwnames[] = { "self","_self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellRenderer__setOORInfo",_kwnames,&_argo0,&_obj1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer__setOORInfo. Expected _wxGridCellRenderer_p.");
+        return NULL;
+        }
+    }
+{
+  _arg1 = _obj1;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellRenderer__setOORInfo(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
  #define wxGridCellRenderer_SetParameters(_swigobj,_swigarg0)  (_swigobj->SetParameters(_swigarg0))
  static PyObject *_wrap_wxGridCellRenderer_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
  #define wxGridCellRenderer_SetParameters(_swigobj,_swigarg0)  (_swigobj->SetParameters(_swigarg0))
  static PyObject *_wrap_wxGridCellRenderer_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
@@ -895,28 +994,15 @@ 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, wxStringErrorMsg);
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          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_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellRenderer_SetParameters(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellRenderer_SetParameters(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -945,10 +1031,10 @@ static PyObject *_wrap_wxGridCellRenderer_IncRef(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellRenderer_IncRef(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellRenderer_IncRef(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -973,10 +1059,10 @@ static PyObject *_wrap_wxGridCellRenderer_DecRef(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellRenderer_DecRef(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellRenderer_DecRef(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1041,10 +1127,10 @@ static PyObject *_wrap_wxGridCellRenderer_Draw(PyObject *self, PyObject *args, P
  }
      _arg7 = (bool ) tempbool7;
  {
  }
      _arg7 = (bool ) tempbool7;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellRenderer_Draw(_arg0,*_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellRenderer_Draw(_arg0,*_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1100,10 +1186,10 @@ static PyObject *_wrap_wxGridCellRenderer_GetBestSize(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxSize (wxGridCellRenderer_GetBestSize(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxSize (wxGridCellRenderer_GetBestSize(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -1117,7 +1203,6 @@ static PyObject *_wrap_wxGridCellRenderer_Clone(PyObject *self, PyObject *args,
      wxGridCellRenderer * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
      wxGridCellRenderer * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_Clone",_kwnames,&_argo0)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_Clone",_kwnames,&_argo0)) 
@@ -1130,18 +1215,12 @@ static PyObject *_wrap_wxGridCellRenderer_Clone(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellRenderer *)wxGridCellRenderer_Clone(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellRenderer *)wxGridCellRenderer_Clone(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellRenderer(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -1164,10 +1243,10 @@ static PyObject *_wrap_new_wxPyGridCellRenderer(PyObject *self, PyObject *args,
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellRenderer",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellRenderer",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxPyGridCellRenderer *)new_wxPyGridCellRenderer();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxPyGridCellRenderer *)new_wxPyGridCellRenderer();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellRenderer_p");
@@ -1179,8 +1258,8 @@ static PyObject *_wrap_new_wxPyGridCellRenderer(PyObject *self, PyObject *args,
      return _resultobj;
  }
  
      return _resultobj;
  }
  
-#define wxPyGridCellRenderer__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxPyGridCellRenderer__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxPyGridCellRenderer__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyGridCellRenderer__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxPyGridCellRenderer * _arg0;
      PyObject * _arg1;
      PyObject * _resultobj;
      wxPyGridCellRenderer * _arg0;
      PyObject * _arg1;
@@ -1191,12 +1270,12 @@ static PyObject *_wrap_wxPyGridCellRenderer__setSelf(PyObject *self, PyObject *a
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellRenderer__setSelf",_kwnames,&_argo0,&_obj1,&_obj2)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellRenderer__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2)) 
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellRenderer_p")) {
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellRenderer_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellRenderer__setSelf. Expected _wxPyGridCellRenderer_p.");
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellRenderer__setCallbackInfo. Expected _wxPyGridCellRenderer_p.");
          return NULL;
          }
      }
          return NULL;
          }
      }
@@ -1207,10 +1286,10 @@ static PyObject *_wrap_wxPyGridCellRenderer__setSelf(PyObject *self, PyObject *a
    _arg2 = _obj2;
  }
  {
    _arg2 = _obj2;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellRenderer__setSelf(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellRenderer__setCallbackInfo(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1237,28 +1316,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellRenderer_base_SetParameters(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellRenderer_base_SetParameters(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1288,10 +1354,10 @@ static PyObject *_wrap_new_wxGridCellStringRenderer(PyObject *self, PyObject *ar
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellStringRenderer",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellStringRenderer",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellStringRenderer *)new_wxGridCellStringRenderer();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellStringRenderer *)new_wxGridCellStringRenderer();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellStringRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellStringRenderer_p");
@@ -1330,10 +1396,10 @@ static PyObject *_wrap_new_wxGridCellNumberRenderer(PyObject *self, PyObject *ar
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellNumberRenderer",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellNumberRenderer",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellNumberRenderer *)new_wxGridCellNumberRenderer();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellNumberRenderer *)new_wxGridCellNumberRenderer();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberRenderer_p");
@@ -1374,10 +1440,10 @@ static PyObject *_wrap_new_wxGridCellFloatRenderer(PyObject *self, PyObject *arg
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellFloatRenderer",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellFloatRenderer",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellFloatRenderer *)new_wxGridCellFloatRenderer(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellFloatRenderer *)new_wxGridCellFloatRenderer(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatRenderer_p");
@@ -1408,10 +1474,10 @@ static PyObject *_wrap_wxGridCellFloatRenderer_GetWidth(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridCellFloatRenderer_GetWidth(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridCellFloatRenderer_GetWidth(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -1436,10 +1502,10 @@ static PyObject *_wrap_wxGridCellFloatRenderer_SetWidth(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellFloatRenderer_SetWidth(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellFloatRenderer_SetWidth(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1465,10 +1531,10 @@ static PyObject *_wrap_wxGridCellFloatRenderer_GetPrecision(PyObject *self, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridCellFloatRenderer_GetPrecision(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridCellFloatRenderer_GetPrecision(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -1493,10 +1559,10 @@ static PyObject *_wrap_wxGridCellFloatRenderer_SetPrecision(PyObject *self, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellFloatRenderer_SetPrecision(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellFloatRenderer_SetPrecision(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1522,10 +1588,10 @@ static PyObject *_wrap_new_wxGridCellBoolRenderer(PyObject *self, PyObject *args
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolRenderer",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolRenderer",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellBoolRenderer *)new_wxGridCellBoolRenderer();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellBoolRenderer *)new_wxGridCellBoolRenderer();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolRenderer_p");
@@ -1557,8 +1623,8 @@ static void *SwigwxGridCellDateTimeRendererTowxGridCellRenderer(void *ptr) {
  static PyObject *_wrap_new_wxGridCellDateTimeRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellDateTimeRenderer * _result;
  static PyObject *_wrap_new_wxGridCellDateTimeRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellDateTimeRenderer * _result;
-    wxString * _arg0 = (wxString *) &"%c";
-    wxString * _arg1 = (wxString *) &"%c";
+    wxString * _arg0 = (wxString *) &wxPyDateTimeFormatStr;
+    wxString * _arg1 = (wxString *) &wxPyDateTimeFormatStr;
      PyObject * _obj0 = 0;
      PyObject * _obj1 = 0;
      char *_kwnames[] = { "outformat","informat", NULL };
      PyObject * _obj0 = 0;
      PyObject * _obj1 = 0;
      char *_kwnames[] = { "outformat","informat", NULL };
@@ -1569,47 +1635,21 @@ static PyObject *_wrap_new_wxGridCellDateTimeRenderer(PyObject *self, PyObject *
          return NULL;
      if (_obj0)
  {
          return NULL;
      if (_obj0)
  {
-#if PYTHON_API_VERSION >= 1009
-    char* tmpPtr; int tmpSize;
-    if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+    _arg0 = wxString_in_helper(_obj0);
+    if (_arg0 == NULL)
          return NULL;
          return NULL;
-    }
-    if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
-        return NULL;
-    _arg0 = new wxString(tmpPtr, tmpSize);
-#else
-    if (!PyString_Check(_obj0)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
-#endif
  }
      if (_obj1)
  {
  }
      if (_obj1)
  {
-#if PYTHON_API_VERSION >= 1009
-    char* tmpPtr; int tmpSize;
-    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        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);
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellDateTimeRenderer *)new_wxGridCellDateTimeRenderer(*_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellDateTimeRenderer *)new_wxGridCellDateTimeRenderer(*_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellDateTimeRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellDateTimeRenderer_p");
@@ -1649,7 +1689,7 @@ static void *SwigwxGridCellEnumRendererTowxGridCellRenderer(void *ptr) {
  static PyObject *_wrap_new_wxGridCellEnumRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellEnumRenderer * _result;
  static PyObject *_wrap_new_wxGridCellEnumRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellEnumRenderer * _result;
-    wxString * _arg0 = (wxString *) &"";
+    wxString * _arg0 = (wxString *) &wxPyEmptyString;
      PyObject * _obj0 = 0;
      char *_kwnames[] = { "choices", NULL };
      char _ptemp[128];
      PyObject * _obj0 = 0;
      char *_kwnames[] = { "choices", NULL };
      char _ptemp[128];
@@ -1665,10 +1705,10 @@ static PyObject *_wrap_new_wxGridCellEnumRenderer(PyObject *self, PyObject *args
      }
  }
  {
      }
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEnumRenderer *)new_wxGridCellEnumRenderer(*_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEnumRenderer *)new_wxGridCellEnumRenderer(*_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumRenderer_p");
@@ -1710,10 +1750,10 @@ static PyObject *_wrap_new_wxGridCellAutoWrapStringRenderer(PyObject *self, PyOb
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringRenderer",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringRenderer",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAutoWrapStringRenderer *)new_wxGridCellAutoWrapStringRenderer();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAutoWrapStringRenderer *)new_wxGridCellAutoWrapStringRenderer();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringRenderer_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringRenderer_p");
@@ -1725,6 +1765,41 @@ static PyObject *_wrap_new_wxGridCellAutoWrapStringRenderer(PyObject *self, PyOb
      return _resultobj;
  }
  
      return _resultobj;
  }
  
+static void  wxGridCellEditor__setOORInfo(wxGridCellEditor *self,PyObject * _self) {
+            self->SetClientObject(new wxPyOORClientData(_self));
+        }
+static PyObject *_wrap_wxGridCellEditor__setOORInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxGridCellEditor * _arg0;
+    PyObject * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _obj1 = 0;
+    char *_kwnames[] = { "self","_self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor__setOORInfo",_kwnames,&_argo0,&_obj1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor__setOORInfo. Expected _wxGridCellEditor_p.");
+        return NULL;
+        }
+    }
+{
+  _arg1 = _obj1;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor__setOORInfo(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
  #define wxGridCellEditor_IsCreated(_swigobj)  (_swigobj->IsCreated())
  static PyObject *_wrap_wxGridCellEditor_IsCreated(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
  #define wxGridCellEditor_IsCreated(_swigobj)  (_swigobj->IsCreated())
  static PyObject *_wrap_wxGridCellEditor_IsCreated(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
@@ -1744,10 +1819,10 @@ static PyObject *_wrap_wxGridCellEditor_IsCreated(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellEditor_IsCreated(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellEditor_IsCreated(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -1772,10 +1847,10 @@ static PyObject *_wrap_wxGridCellEditor_GetControl(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxControl *)wxGridCellEditor_GetControl(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxControl *)wxGridCellEditor_GetControl(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
@@ -1808,10 +1883,10 @@ static PyObject *_wrap_wxGridCellEditor_SetControl(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_SetControl(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_SetControl(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1838,28 +1913,15 @@ 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, wxStringErrorMsg);
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          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_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_SetParameters(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_SetParameters(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1888,10 +1950,10 @@ static PyObject *_wrap_wxGridCellEditor_IncRef(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_IncRef(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_IncRef(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1916,10 +1978,10 @@ static PyObject *_wrap_wxGridCellEditor_DecRef(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_DecRef(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_DecRef(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -1963,10 +2025,10 @@ static PyObject *_wrap_wxGridCellEditor_Create(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_Create(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_Create(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2002,10 +2064,10 @@ static PyObject *_wrap_wxGridCellEditor_BeginEdit(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_BeginEdit(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_BeginEdit(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2042,10 +2104,10 @@ static PyObject *_wrap_wxGridCellEditor_EndEdit(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellEditor_EndEdit(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellEditor_EndEdit(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -2069,10 +2131,10 @@ static PyObject *_wrap_wxGridCellEditor_Reset(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_Reset(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_Reset(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2086,7 +2148,6 @@ static PyObject *_wrap_wxGridCellEditor_Clone(PyObject *self, PyObject *args, Py
      wxGridCellEditor * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
      wxGridCellEditor * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Clone",_kwnames,&_argo0)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Clone",_kwnames,&_argo0)) 
@@ -2099,18 +2160,12 @@ static PyObject *_wrap_wxGridCellEditor_Clone(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEditor *)wxGridCellEditor_Clone(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEditor *)wxGridCellEditor_Clone(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellEditor(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -2140,10 +2195,10 @@ static PyObject *_wrap_wxGridCellEditor_SetSize(PyObject *self, PyObject *args,
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_SetSize(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_SetSize(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2180,10 +2235,10 @@ static PyObject *_wrap_wxGridCellEditor_Show(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_Show(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_Show(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2225,10 +2280,10 @@ static PyObject *_wrap_wxGridCellEditor_PaintBackground(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_PaintBackground(_arg0,*_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_PaintBackground(_arg0,*_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2263,10 +2318,10 @@ static PyObject *_wrap_wxGridCellEditor_IsAcceptedKey(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellEditor_IsAcceptedKey(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellEditor_IsAcceptedKey(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -2299,10 +2354,10 @@ static PyObject *_wrap_wxGridCellEditor_StartingKey(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_StartingKey(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_StartingKey(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2327,10 +2382,10 @@ static PyObject *_wrap_wxGridCellEditor_StartingClick(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_StartingClick(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_StartingClick(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2364,10 +2419,10 @@ static PyObject *_wrap_wxGridCellEditor_HandleReturn(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_HandleReturn(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_HandleReturn(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2392,10 +2447,10 @@ static PyObject *_wrap_wxGridCellEditor_Destroy(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellEditor_Destroy(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellEditor_Destroy(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2421,10 +2476,10 @@ static PyObject *_wrap_new_wxPyGridCellEditor(PyObject *self, PyObject *args, Py
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellEditor",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellEditor",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxPyGridCellEditor *)new_wxPyGridCellEditor();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxPyGridCellEditor *)new_wxPyGridCellEditor();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellEditor_p");
@@ -2436,8 +2491,8 @@ static PyObject *_wrap_new_wxPyGridCellEditor(PyObject *self, PyObject *args, Py
      return _resultobj;
  }
  
      return _resultobj;
  }
  
-#define wxPyGridCellEditor__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxPyGridCellEditor__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxPyGridCellEditor__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyGridCellEditor__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxPyGridCellEditor * _arg0;
      PyObject * _arg1;
      PyObject * _resultobj;
      wxPyGridCellEditor * _arg0;
      PyObject * _arg1;
@@ -2448,12 +2503,12 @@ static PyObject *_wrap_wxPyGridCellEditor__setSelf(PyObject *self, PyObject *arg
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellEditor__setSelf",_kwnames,&_argo0,&_obj1,&_obj2)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellEditor__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2)) 
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
          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__setSelf. Expected _wxPyGridCellEditor_p.");
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor__setCallbackInfo. Expected _wxPyGridCellEditor_p.");
          return NULL;
          }
      }
          return NULL;
          }
      }
@@ -2464,10 +2519,10 @@ static PyObject *_wrap_wxPyGridCellEditor__setSelf(PyObject *self, PyObject *arg
    _arg2 = _obj2;
  }
  {
    _arg2 = _obj2;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor__setSelf(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor__setCallbackInfo(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2500,10 +2555,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_SetSize(PyObject *self, PyObject
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_SetSize(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_SetSize(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2540,10 +2595,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_Show(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_Show(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_Show(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2585,10 +2640,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_PaintBackground(PyObject *self, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_PaintBackground(_arg0,*_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_PaintBackground(_arg0,*_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2622,10 +2677,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_IsAcceptedKey(PyObject *self, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_IsAcceptedKey(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_IsAcceptedKey(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2659,10 +2714,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_StartingKey(PyObject *self, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_StartingKey(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_StartingKey(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2687,10 +2742,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_StartingClick(PyObject *self, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_StartingClick(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_StartingClick(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2724,10 +2779,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_HandleReturn(PyObject *self, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_HandleReturn(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_HandleReturn(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2752,10 +2807,10 @@ static PyObject *_wrap_wxPyGridCellEditor_base_Destroy(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_Destroy(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_Destroy(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2782,28 +2837,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellEditor_base_SetParameters(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellEditor_base_SetParameters(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -2833,10 +2875,10 @@ static PyObject *_wrap_new_wxGridCellTextEditor(PyObject *self, PyObject *args,
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellTextEditor",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellTextEditor",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellTextEditor *)new_wxGridCellTextEditor();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellTextEditor *)new_wxGridCellTextEditor();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellTextEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellTextEditor_p");
@@ -2877,10 +2919,10 @@ static PyObject *_wrap_new_wxGridCellNumberEditor(PyObject *self, PyObject *args
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellNumberEditor",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellNumberEditor",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellNumberEditor *)new_wxGridCellNumberEditor(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellNumberEditor *)new_wxGridCellNumberEditor(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberEditor_p");
@@ -2919,10 +2961,10 @@ static PyObject *_wrap_new_wxGridCellFloatEditor(PyObject *self, PyObject *args,
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellFloatEditor",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellFloatEditor",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellFloatEditor *)new_wxGridCellFloatEditor();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellFloatEditor *)new_wxGridCellFloatEditor();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatEditor_p");
@@ -2953,10 +2995,10 @@ static PyObject *_wrap_new_wxGridCellBoolEditor(PyObject *self, PyObject *args,
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolEditor",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolEditor",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellBoolEditor *)new_wxGridCellBoolEditor();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellBoolEditor *)new_wxGridCellBoolEditor();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolEditor_p");
@@ -3008,10 +3050,10 @@ static PyObject *_wrap_new_wxGridCellChoiceEditor(PyObject *self, PyObject *args
      }
  }
  {
      }
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellChoiceEditor *)new_wxGridCellChoiceEditor(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellChoiceEditor *)new_wxGridCellChoiceEditor(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellChoiceEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellChoiceEditor_p");
@@ -3046,7 +3088,7 @@ static void *SwigwxGridCellEnumEditorTowxGridCellEditor(void *ptr) {
  static PyObject *_wrap_new_wxGridCellEnumEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellEnumEditor * _result;
  static PyObject *_wrap_new_wxGridCellEnumEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellEnumEditor * _result;
-    wxString * _arg0 = (wxString *) &"";
+    wxString * _arg0 = (wxString *) &wxPyEmptyString;
      PyObject * _obj0 = 0;
      char *_kwnames[] = { "choices", NULL };
      char _ptemp[128];
      PyObject * _obj0 = 0;
      char *_kwnames[] = { "choices", NULL };
      char _ptemp[128];
@@ -3062,10 +3104,10 @@ static PyObject *_wrap_new_wxGridCellEnumEditor(PyObject *self, PyObject *args,
      }
  }
  {
      }
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEnumEditor *)new_wxGridCellEnumEditor(*_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEnumEditor *)new_wxGridCellEnumEditor(*_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumEditor_p");
@@ -3107,10 +3149,10 @@ static PyObject *_wrap_new_wxGridCellAutoWrapStringEditor(PyObject *self, PyObje
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringEditor",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringEditor",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAutoWrapStringEditor *)new_wxGridCellAutoWrapStringEditor();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAutoWrapStringEditor *)new_wxGridCellAutoWrapStringEditor();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringEditor_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringEditor_p");
@@ -3122,21 +3164,65 @@ static PyObject *_wrap_new_wxGridCellAutoWrapStringEditor(PyObject *self, PyObje
      return _resultobj;
  }
  
      return _resultobj;
  }
  
-#define new_wxGridCellAttr() (new wxGridCellAttr())
+static void  wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject * _self) {
+            self->SetClientObject(new wxPyOORClientData(_self));
+        }
+static PyObject *_wrap_wxGridCellAttr__setOORInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxGridCellAttr * _arg0;
+    PyObject * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _obj1 = 0;
+    char *_kwnames[] = { "self","_self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr__setOORInfo",_kwnames,&_argo0,&_obj1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr__setOORInfo. Expected _wxGridCellAttr_p.");
+        return NULL;
+        }
+    }
+{
+  _arg1 = _obj1;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr__setOORInfo(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define new_wxGridCellAttr(_swigarg0) (new wxGridCellAttr(_swigarg0))
  static PyObject *_wrap_new_wxGridCellAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellAttr * _result;
  static PyObject *_wrap_new_wxGridCellAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxGridCellAttr * _result;
-    char *_kwnames[] = {  NULL };
+    wxGridCellAttr * _arg0 = (wxGridCellAttr *) NULL;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "attrDefault", NULL };
      char _ptemp[128];
  
      self = self;
      char _ptemp[128];
  
      self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAttr",_kwnames)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|O:new_wxGridCellAttr",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGridCellAttr. Expected _wxGridCellAttr_p.");
          return NULL;
          return NULL;
+        }
+    }
  {
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttr *)new_wxGridCellAttr();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttr *)new_wxGridCellAttr(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
@@ -3155,7 +3241,6 @@ static PyObject *_wrap_wxGridCellAttr_Clone(PyObject *self, PyObject *args, PyOb
      wxGridCellAttr * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
      wxGridCellAttr * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_Clone",_kwnames,&_argo0)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_Clone",_kwnames,&_argo0)) 
@@ -3168,18 +3253,12 @@ static PyObject *_wrap_wxGridCellAttr_Clone(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttr *)wxGridCellAttr_Clone(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttr *)wxGridCellAttr_Clone(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellAttr(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -3210,10 +3289,10 @@ static PyObject *_wrap_wxGridCellAttr_MergeWith(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_MergeWith(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_MergeWith(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3238,10 +3317,10 @@ static PyObject *_wrap_wxGridCellAttr_IncRef(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_IncRef(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_IncRef(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3266,10 +3345,10 @@ static PyObject *_wrap_wxGridCellAttr_DecRef(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_DecRef(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_DecRef(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3302,10 +3381,10 @@ static PyObject *_wrap_wxGridCellAttr_SetTextColour(PyObject *self, PyObject *ar
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetTextColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetTextColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3338,10 +3417,10 @@ static PyObject *_wrap_wxGridCellAttr_SetBackgroundColour(PyObject *self, PyObje
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetBackgroundColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetBackgroundColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3375,10 +3454,10 @@ static PyObject *_wrap_wxGridCellAttr_SetFont(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetFont(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetFont(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3405,10 +3484,10 @@ static PyObject *_wrap_wxGridCellAttr_SetAlignment(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3436,10 +3515,10 @@ static PyObject *_wrap_wxGridCellAttr_SetReadOnly(PyObject *self, PyObject *args
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetReadOnly(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetReadOnly(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3473,10 +3552,10 @@ static PyObject *_wrap_wxGridCellAttr_SetRenderer(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetRenderer(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetRenderer(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3510,10 +3589,10 @@ static PyObject *_wrap_wxGridCellAttr_SetEditor(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetEditor(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetEditor(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3539,10 +3618,10 @@ static PyObject *_wrap_wxGridCellAttr_SetKind(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetKind(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetKind(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3568,10 +3647,10 @@ static PyObject *_wrap_wxGridCellAttr_HasTextColour(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_HasTextColour(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_HasTextColour(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -3596,10 +3675,10 @@ static PyObject *_wrap_wxGridCellAttr_HasBackgroundColour(PyObject *self, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_HasBackgroundColour(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_HasBackgroundColour(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -3624,10 +3703,10 @@ static PyObject *_wrap_wxGridCellAttr_HasFont(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_HasFont(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_HasFont(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -3652,10 +3731,10 @@ static PyObject *_wrap_wxGridCellAttr_HasAlignment(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_HasAlignment(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_HasAlignment(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -3680,10 +3759,10 @@ static PyObject *_wrap_wxGridCellAttr_HasRenderer(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_HasRenderer(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_HasRenderer(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -3708,10 +3787,10 @@ static PyObject *_wrap_wxGridCellAttr_HasEditor(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_HasEditor(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_HasEditor(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -3736,10 +3815,10 @@ static PyObject *_wrap_wxGridCellAttr_HasReadWriteMode(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_HasReadWriteMode(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_HasReadWriteMode(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -3765,19 +3844,13 @@ static PyObject *_wrap_wxGridCellAttr_GetTextColour(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        const wxColour & _result_ref = wxGridCellAttr_GetTextColour(_arg0);
-    _result = (wxColour *) &_result_ref;
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGridCellAttr_GetTextColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -3801,19 +3874,13 @@ static PyObject *_wrap_wxGridCellAttr_GetBackgroundColour(PyObject *self, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        const wxColour & _result_ref = wxGridCellAttr_GetBackgroundColour(_arg0);
-    _result = (wxColour *) &_result_ref;
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGridCellAttr_GetBackgroundColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -3837,19 +3904,13 @@ static PyObject *_wrap_wxGridCellAttr_GetFont(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        const wxFont & _result_ref = wxGridCellAttr_GetFont(_arg0);
-    _result = (wxFont *) &_result_ref;
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxFont (wxGridCellAttr_GetFont(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -3881,10 +3942,10 @@ static PyObject *_wrap_wxGridCellAttr_GetAlignment(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_GetAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_GetAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -3912,7 +3973,6 @@ static PyObject *_wrap_wxGridCellAttr_GetRenderer(PyObject *self, PyObject *args
      PyObject * _argo0 = 0;
      PyObject * _argo1 = 0;
      char *_kwnames[] = { "self","grid","row","col", NULL };
      PyObject * _argo0 = 0;
      PyObject * _argo1 = 0;
      char *_kwnames[] = { "self","grid","row","col", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetRenderer",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetRenderer",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3)) 
@@ -3932,18 +3992,12 @@ static PyObject *_wrap_wxGridCellAttr_GetRenderer(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellRenderer *)wxGridCellAttr_GetRenderer(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellRenderer *)wxGridCellAttr_GetRenderer(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellRenderer(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -3958,7 +4012,6 @@ static PyObject *_wrap_wxGridCellAttr_GetEditor(PyObject *self, PyObject *args,
      PyObject * _argo0 = 0;
      PyObject * _argo1 = 0;
      char *_kwnames[] = { "self","grid","row","col", NULL };
      PyObject * _argo0 = 0;
      PyObject * _argo1 = 0;
      char *_kwnames[] = { "self","grid","row","col", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetEditor",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetEditor",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3)) 
@@ -3978,18 +4031,12 @@ static PyObject *_wrap_wxGridCellAttr_GetEditor(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEditor *)wxGridCellAttr_GetEditor(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEditor *)wxGridCellAttr_GetEditor(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellEditor(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -4012,10 +4059,10 @@ static PyObject *_wrap_wxGridCellAttr_IsReadOnly(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridCellAttr_IsReadOnly(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridCellAttr_IsReadOnly(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -4048,10 +4095,10 @@ static PyObject *_wrap_wxGridCellAttr_SetDefAttr(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttr_SetDefAttr(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttr_SetDefAttr(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4069,10 +4116,10 @@ static PyObject *_wrap_new_wxGridCellAttrProvider(PyObject *self, PyObject *args
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAttrProvider",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAttrProvider",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttrProvider *)new_wxGridCellAttrProvider();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttrProvider *)new_wxGridCellAttrProvider();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttrProvider_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttrProvider_p");
@@ -4084,6 +4131,41 @@ static PyObject *_wrap_new_wxGridCellAttrProvider(PyObject *self, PyObject *args
      return _resultobj;
  }
  
      return _resultobj;
  }
  
+static void  wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject * _self) {
+            self->SetClientObject(new wxPyOORClientData(_self));
+        }
+static PyObject *_wrap_wxGridCellAttrProvider__setOORInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxGridCellAttrProvider * _arg0;
+    PyObject * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _obj1 = 0;
+    char *_kwnames[] = { "self","_self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttrProvider__setOORInfo",_kwnames,&_argo0,&_obj1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider__setOORInfo. Expected _wxGridCellAttrProvider_p.");
+        return NULL;
+        }
+    }
+{
+  _arg1 = _obj1;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttrProvider__setOORInfo(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
  #define wxGridCellAttrProvider_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetAttr(_swigarg0,_swigarg1,_swigarg2))
  static PyObject *_wrap_wxGridCellAttrProvider_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
  #define wxGridCellAttrProvider_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetAttr(_swigarg0,_swigarg1,_swigarg2))
  static PyObject *_wrap_wxGridCellAttrProvider_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
@@ -4094,7 +4176,6 @@ static PyObject *_wrap_wxGridCellAttrProvider_GetAttr(PyObject *self, PyObject *
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridCellAttrProvider_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridCellAttrProvider_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
@@ -4107,18 +4188,12 @@ static PyObject *_wrap_wxGridCellAttrProvider_GetAttr(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttr *)wxGridCellAttrProvider_GetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttr *)wxGridCellAttrProvider_GetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellAttr(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -4151,10 +4226,10 @@ static PyObject *_wrap_wxGridCellAttrProvider_SetAttr(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttrProvider_SetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttrProvider_SetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4189,10 +4264,10 @@ static PyObject *_wrap_wxGridCellAttrProvider_SetRowAttr(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttrProvider_SetRowAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttrProvider_SetRowAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4227,10 +4302,10 @@ static PyObject *_wrap_wxGridCellAttrProvider_SetColAttr(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttrProvider_SetColAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttrProvider_SetColAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4257,10 +4332,10 @@ static PyObject *_wrap_wxGridCellAttrProvider_UpdateAttrRows(PyObject *self, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttrProvider_UpdateAttrRows(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttrProvider_UpdateAttrRows(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4287,10 +4362,10 @@ static PyObject *_wrap_wxGridCellAttrProvider_UpdateAttrCols(PyObject *self, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellAttrProvider_UpdateAttrCols(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellAttrProvider_UpdateAttrCols(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4316,10 +4391,10 @@ static PyObject *_wrap_new_wxPyGridCellAttrProvider(PyObject *self, PyObject *ar
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellAttrProvider",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellAttrProvider",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxPyGridCellAttrProvider *)new_wxPyGridCellAttrProvider();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxPyGridCellAttrProvider *)new_wxPyGridCellAttrProvider();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellAttrProvider_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellAttrProvider_p");
@@ -4331,8 +4406,8 @@ static PyObject *_wrap_new_wxPyGridCellAttrProvider(PyObject *self, PyObject *ar
      return _resultobj;
  }
  
      return _resultobj;
  }
  
-#define wxPyGridCellAttrProvider__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxPyGridCellAttrProvider__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxPyGridCellAttrProvider__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyGridCellAttrProvider__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxPyGridCellAttrProvider * _arg0;
      PyObject * _arg1;
      PyObject * _resultobj;
      wxPyGridCellAttrProvider * _arg0;
      PyObject * _arg1;
@@ -4343,12 +4418,12 @@ static PyObject *_wrap_wxPyGridCellAttrProvider__setSelf(PyObject *self, PyObjec
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellAttrProvider__setSelf",_kwnames,&_argo0,&_obj1,&_obj2)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellAttrProvider__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2)) 
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider__setSelf. Expected _wxPyGridCellAttrProvider_p.");
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider__setCallbackInfo. Expected _wxPyGridCellAttrProvider_p.");
          return NULL;
          }
      }
          return NULL;
          }
      }
@@ -4359,10 +4434,10 @@ static PyObject *_wrap_wxPyGridCellAttrProvider__setSelf(PyObject *self, PyObjec
    _arg2 = _obj2;
  }
  {
    _arg2 = _obj2;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellAttrProvider__setSelf(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellAttrProvider__setCallbackInfo(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4379,7 +4454,6 @@ static PyObject *_wrap_wxPyGridCellAttrProvider_base_GetAttr(PyObject *self, PyO
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridCellAttrProvider_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridCellAttrProvider_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
@@ -4392,18 +4466,12 @@ static PyObject *_wrap_wxPyGridCellAttrProvider_base_GetAttr(PyObject *self, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttr *)wxPyGridCellAttrProvider_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttr *)wxPyGridCellAttrProvider_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellAttr(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -4436,10 +4504,10 @@ static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetAttr(PyObject *self, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellAttrProvider_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellAttrProvider_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4474,10 +4542,10 @@ static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetRowAttr(PyObject *self,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellAttrProvider_base_SetRowAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellAttrProvider_base_SetRowAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4512,10 +4580,10 @@ static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetColAttr(PyObject *self,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridCellAttrProvider_base_SetColAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridCellAttrProvider_base_SetColAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4530,6 +4598,41 @@ static void *SwigwxGridTableBaseTowxObject(void *ptr) {
      return (void *) dest;
  }
  
      return (void *) dest;
  }
  
+static void  wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject * _self) {
+            self->SetClientObject(new wxPyOORClientData(_self));
+        }
+static PyObject *_wrap_wxGridTableBase__setOORInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxGridTableBase * _arg0;
+    PyObject * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _obj1 = 0;
+    char *_kwnames[] = { "self","_self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridTableBase__setOORInfo",_kwnames,&_argo0,&_obj1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase__setOORInfo. Expected _wxGridTableBase_p.");
+        return NULL;
+        }
+    }
+{
+  _arg1 = _obj1;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase__setOORInfo(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
  #define wxGridTableBase_SetAttrProvider(_swigobj,_swigarg0)  (_swigobj->SetAttrProvider(_swigarg0))
  static PyObject *_wrap_wxGridTableBase_SetAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
  #define wxGridTableBase_SetAttrProvider(_swigobj,_swigarg0)  (_swigobj->SetAttrProvider(_swigarg0))
  static PyObject *_wrap_wxGridTableBase_SetAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
@@ -4557,10 +4660,10 @@ static PyObject *_wrap_wxGridTableBase_SetAttrProvider(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetAttrProvider(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetAttrProvider(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4574,7 +4677,6 @@ static PyObject *_wrap_wxGridTableBase_GetAttrProvider(PyObject *self, PyObject
      wxGridTableBase * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
      wxGridTableBase * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetAttrProvider",_kwnames,&_argo0)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetAttrProvider",_kwnames,&_argo0)) 
@@ -4587,18 +4689,12 @@ static PyObject *_wrap_wxGridTableBase_GetAttrProvider(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttrProvider *)wxGridTableBase_GetAttrProvider(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttrProvider *)wxGridTableBase_GetAttrProvider(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttrProvider_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellAttrProvider(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -4629,10 +4725,10 @@ static PyObject *_wrap_wxGridTableBase_SetView(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetView(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetView(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4658,10 +4754,10 @@ static PyObject *_wrap_wxGridTableBase_GetView(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGrid *)wxGridTableBase_GetView(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGrid *)wxGridTableBase_GetView(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
@@ -4686,10 +4782,10 @@ static PyObject *_wrap_wxGridTableBase_GetNumberRows(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridTableBase_GetNumberRows(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridTableBase_GetNumberRows(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -4714,10 +4810,10 @@ static PyObject *_wrap_wxGridTableBase_GetNumberCols(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridTableBase_GetNumberCols(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridTableBase_GetNumberCols(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -4744,10 +4840,10 @@ static PyObject *_wrap_wxGridTableBase_IsEmptyCell(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_IsEmptyCell(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_IsEmptyCell(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -4774,13 +4870,17 @@ static PyObject *_wrap_wxGridTableBase_GetValue(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxGridTableBase_GetValue(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxGridTableBase_GetValue(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -4810,28 +4910,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg3 = wxString_in_helper(_obj3);
+    if (_arg3 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetValue(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetValue(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -4863,13 +4950,17 @@ static PyObject *_wrap_wxGridTableBase_GetTypeName(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxGridTableBase_GetTypeName(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxGridTableBase_GetTypeName(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -4900,28 +4991,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg3 = wxString_in_helper(_obj3);
+    if (_arg3 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
@@ -4954,28 +5032,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg3 = wxString_in_helper(_obj3);
+    if (_arg3 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
@@ -5006,10 +5071,10 @@ static PyObject *_wrap_wxGridTableBase_GetValueAsLong(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (long )wxGridTableBase_GetValueAsLong(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (long )wxGridTableBase_GetValueAsLong(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("l",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("l",_result);
      return _resultobj;
@@ -5036,10 +5101,10 @@ static PyObject *_wrap_wxGridTableBase_GetValueAsDouble(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (double )wxGridTableBase_GetValueAsDouble(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (double )wxGridTableBase_GetValueAsDouble(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("d",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("d",_result);
      return _resultobj;
@@ -5066,10 +5131,10 @@ static PyObject *_wrap_wxGridTableBase_GetValueAsBool(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_GetValueAsBool(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_GetValueAsBool(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5096,10 +5161,10 @@ static PyObject *_wrap_wxGridTableBase_SetValueAsLong(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetValueAsLong(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetValueAsLong(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5127,10 +5192,10 @@ static PyObject *_wrap_wxGridTableBase_SetValueAsDouble(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetValueAsDouble(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetValueAsDouble(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5160,10 +5225,10 @@ static PyObject *_wrap_wxGridTableBase_SetValueAsBool(PyObject *self, PyObject *
      }
      _arg3 = (bool ) tempbool3;
  {
      }
      _arg3 = (bool ) tempbool3;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetValueAsBool(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetValueAsBool(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5188,10 +5253,10 @@ static PyObject *_wrap_wxGridTableBase_Clear(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_Clear(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_Clear(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5219,10 +5284,10 @@ static PyObject *_wrap_wxGridTableBase_InsertRows(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_InsertRows(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_InsertRows(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5248,10 +5313,10 @@ static PyObject *_wrap_wxGridTableBase_AppendRows(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_AppendRows(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_AppendRows(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5278,10 +5343,10 @@ static PyObject *_wrap_wxGridTableBase_DeleteRows(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_DeleteRows(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_DeleteRows(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5308,10 +5373,10 @@ static PyObject *_wrap_wxGridTableBase_InsertCols(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_InsertCols(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_InsertCols(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5337,10 +5402,10 @@ static PyObject *_wrap_wxGridTableBase_AppendCols(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_AppendCols(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_AppendCols(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5367,10 +5432,10 @@ static PyObject *_wrap_wxGridTableBase_DeleteCols(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_DeleteCols(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_DeleteCols(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5396,13 +5461,17 @@ static PyObject *_wrap_wxGridTableBase_GetRowLabelValue(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxGridTableBase_GetRowLabelValue(_arg0,_arg1));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxGridTableBase_GetRowLabelValue(_arg0,_arg1));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -5430,13 +5499,17 @@ static PyObject *_wrap_wxGridTableBase_GetColLabelValue(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxGridTableBase_GetColLabelValue(_arg0,_arg1));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxGridTableBase_GetColLabelValue(_arg0,_arg1));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -5465,28 +5538,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetRowLabelValue(_arg0,_arg1,*_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetRowLabelValue(_arg0,_arg1,*_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5518,28 +5578,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetColLabelValue(_arg0,_arg1,*_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetColLabelValue(_arg0,_arg1,*_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5569,10 +5616,10 @@ static PyObject *_wrap_wxGridTableBase_CanHaveAttributes(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridTableBase_CanHaveAttributes(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridTableBase_CanHaveAttributes(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -5588,7 +5635,6 @@ static PyObject *_wrap_wxGridTableBase_GetAttr(PyObject *self, PyObject *args, P
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridTableBase_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridTableBase_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
@@ -5601,18 +5647,12 @@ static PyObject *_wrap_wxGridTableBase_GetAttr(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttr *)wxGridTableBase_GetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttr *)wxGridTableBase_GetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellAttr(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -5645,10 +5685,10 @@ static PyObject *_wrap_wxGridTableBase_SetAttr(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5683,10 +5723,10 @@ static PyObject *_wrap_wxGridTableBase_SetRowAttr(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetRowAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetRowAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5721,10 +5761,10 @@ static PyObject *_wrap_wxGridTableBase_SetColAttr(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableBase_SetColAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableBase_SetColAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5758,10 +5798,10 @@ static PyObject *_wrap_new_wxPyGridTableBase(PyObject *self, PyObject *args, PyO
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridTableBase",_kwnames)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridTableBase",_kwnames)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxPyGridTableBase *)new_wxPyGridTableBase();
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxPyGridTableBase *)new_wxPyGridTableBase();
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridTableBase_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridTableBase_p");
@@ -5773,8 +5813,8 @@ static PyObject *_wrap_new_wxPyGridTableBase(PyObject *self, PyObject *args, PyO
      return _resultobj;
  }
  
      return _resultobj;
  }
  
-#define wxPyGridTableBase__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxPyGridTableBase__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxPyGridTableBase__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyGridTableBase__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
      wxPyGridTableBase * _arg0;
      PyObject * _arg1;
      PyObject * _resultobj;
      wxPyGridTableBase * _arg0;
      PyObject * _arg1;
@@ -5785,12 +5825,12 @@ static PyObject *_wrap_wxPyGridTableBase__setSelf(PyObject *self, PyObject *args
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
      char *_kwnames[] = { "self","self","_class", NULL };
  
      self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridTableBase__setSelf",_kwnames,&_argo0,&_obj1,&_obj2)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridTableBase__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2)) 
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase__setSelf. Expected _wxPyGridTableBase_p.");
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase__setCallbackInfo. Expected _wxPyGridTableBase_p.");
          return NULL;
          }
      }
          return NULL;
          }
      }
@@ -5801,10 +5841,10 @@ static PyObject *_wrap_wxPyGridTableBase__setSelf(PyObject *self, PyObject *args
    _arg2 = _obj2;
  }
  {
    _arg2 = _obj2;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase__setSelf(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase__setCallbackInfo(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5829,10 +5869,10 @@ static PyObject *_wrap_wxPyGridTableBase_Destroy(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase_Destroy(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase_Destroy(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -5860,13 +5900,17 @@ static PyObject *_wrap_wxPyGridTableBase_base_GetTypeName(PyObject *self, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxPyGridTableBase_base_GetTypeName(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxPyGridTableBase_base_GetTypeName(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -5897,28 +5941,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg3 = wxString_in_helper(_obj3);
+    if (_arg3 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
@@ -5951,28 +5982,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg3 = wxString_in_helper(_obj3);
+    if (_arg3 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
  {
@@ -6000,10 +6018,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_Clear(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase_base_Clear(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase_base_Clear(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6031,10 +6049,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_InsertRows(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_InsertRows(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_InsertRows(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6060,10 +6078,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_AppendRows(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_AppendRows(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_AppendRows(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6090,10 +6108,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_DeleteRows(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_DeleteRows(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_DeleteRows(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6120,10 +6138,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_InsertCols(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_InsertCols(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_InsertCols(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6149,10 +6167,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_AppendCols(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_AppendCols(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_AppendCols(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6179,10 +6197,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_DeleteCols(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_DeleteCols(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_DeleteCols(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6208,13 +6226,17 @@ static PyObject *_wrap_wxPyGridTableBase_base_GetRowLabelValue(PyObject *self, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxPyGridTableBase_base_GetRowLabelValue(_arg0,_arg1));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxPyGridTableBase_base_GetRowLabelValue(_arg0,_arg1));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -6242,13 +6264,17 @@ static PyObject *_wrap_wxPyGridTableBase_base_GetColLabelValue(PyObject *self, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxPyGridTableBase_base_GetColLabelValue(_arg0,_arg1));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxPyGridTableBase_base_GetColLabelValue(_arg0,_arg1));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -6277,28 +6303,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase_base_SetRowLabelValue(_arg0,_arg1,*_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase_base_SetRowLabelValue(_arg0,_arg1,*_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6330,28 +6343,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase_base_SetColLabelValue(_arg0,_arg1,*_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase_base_SetColLabelValue(_arg0,_arg1,*_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6381,10 +6381,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_CanHaveAttributes(PyObject *self,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxPyGridTableBase_base_CanHaveAttributes(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyGridTableBase_base_CanHaveAttributes(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6400,7 +6400,6 @@ static PyObject *_wrap_wxPyGridTableBase_base_GetAttr(PyObject *self, PyObject *
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
      wxGridCellAttr::wxAttrKind  _arg3;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col","kind", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridTableBase_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridTableBase_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3)) 
@@ -6413,18 +6412,12 @@ static PyObject *_wrap_wxPyGridTableBase_base_GetAttr(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellAttr *)wxPyGridTableBase_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellAttr *)wxPyGridTableBase_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellAttr(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -6457,10 +6450,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_SetAttr(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6495,10 +6488,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_SetRowAttr(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase_base_SetRowAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase_base_SetRowAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6533,10 +6526,10 @@ static PyObject *_wrap_wxPyGridTableBase_base_SetColAttr(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxPyGridTableBase_base_SetColAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyGridTableBase_base_SetColAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6572,10 +6565,10 @@ static PyObject *_wrap_new_wxGridStringTable(PyObject *self, PyObject *args, PyO
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridStringTable",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridStringTable",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridStringTable *)new_wxGridStringTable(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridStringTable *)new_wxGridStringTable(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridStringTable_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridStringTable_p");
@@ -6610,10 +6603,10 @@ static PyObject *_wrap_new_wxGridTableMessage(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridTableMessage *)new_wxGridTableMessage(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridTableMessage *)new_wxGridTableMessage(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridTableMessage_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridTableMessage_p");
@@ -6643,10 +6636,10 @@ static PyObject *_wrap_delete_wxGridTableMessage(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        delete_wxGridTableMessage(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    delete_wxGridTableMessage(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6680,10 +6673,10 @@ static PyObject *_wrap_wxGridTableMessage_SetTableObject(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableMessage_SetTableObject(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableMessage_SetTableObject(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6709,12 +6702,12 @@ static PyObject *_wrap_wxGridTableMessage_GetTableObject(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridTableBase *)wxGridTableMessage_GetTableObject(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridTableBase *)wxGridTableMessage_GetTableObject(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}{ _resultobj = wxPyMake_wxObject(_result); }
+}{ _resultobj = wxPyMake_wxGridTableBase(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -6737,10 +6730,10 @@ static PyObject *_wrap_wxGridTableMessage_SetId(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableMessage_SetId(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableMessage_SetId(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6766,10 +6759,10 @@ static PyObject *_wrap_wxGridTableMessage_GetId(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridTableMessage_GetId(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridTableMessage_GetId(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6794,10 +6787,10 @@ static PyObject *_wrap_wxGridTableMessage_SetCommandInt(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableMessage_SetCommandInt(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableMessage_SetCommandInt(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6823,10 +6816,10 @@ static PyObject *_wrap_wxGridTableMessage_GetCommandInt(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridTableMessage_GetCommandInt(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridTableMessage_GetCommandInt(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6851,10 +6844,10 @@ static PyObject *_wrap_wxGridTableMessage_SetCommandInt2(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridTableMessage_SetCommandInt2(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridTableMessage_SetCommandInt2(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6880,10 +6873,10 @@ static PyObject *_wrap_wxGridTableMessage_GetCommandInt2(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridTableMessage_GetCommandInt2(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridTableMessage_GetCommandInt2(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6902,10 +6895,10 @@ static PyObject *_wrap_new_wxGridCellCoords(PyObject *self, PyObject *args, PyOb
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellCoords",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellCoords",_kwnames,&_arg0,&_arg1)) 
          return NULL;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellCoords *)new_wxGridCellCoords(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellCoords *)new_wxGridCellCoords(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
@@ -6935,10 +6928,10 @@ static PyObject *_wrap_delete_wxGridCellCoords(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        delete_wxGridCellCoords(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    delete_wxGridCellCoords(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -6964,10 +6957,10 @@ static PyObject *_wrap_wxGridCellCoords_GetRow(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridCellCoords_GetRow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridCellCoords_GetRow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -6992,10 +6985,10 @@ static PyObject *_wrap_wxGridCellCoords_SetRow(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellCoords_SetRow(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellCoords_SetRow(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7021,10 +7014,10 @@ static PyObject *_wrap_wxGridCellCoords_GetCol(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridCellCoords_GetCol(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridCellCoords_GetCol(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7049,10 +7042,10 @@ static PyObject *_wrap_wxGridCellCoords_SetCol(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellCoords_SetCol(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellCoords_SetCol(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7079,10 +7072,10 @@ static PyObject *_wrap_wxGridCellCoords_Set(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridCellCoords_Set(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridCellCoords_Set(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7113,10 +7106,10 @@ static PyObject *_wrap_wxGridCellCoords_asTuple(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (PyObject *)wxGridCellCoords_asTuple(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (PyObject *)wxGridCellCoords_asTuple(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
    _resultobj = _result;
      if (PyErr_Occurred()) return NULL;
  }{
    _resultobj = _result;
@@ -7154,10 +7147,10 @@ static PyObject *_wrap_wxGridCellCoords___cmp__(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridCellCoords___cmp__(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridCellCoords___cmp__(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7212,17 +7205,18 @@ static PyObject *_wrap_new_wxGrid(PyObject *self, PyObject *args, PyObject *kwar
      wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
      wxSize * _arg3 = (wxSize *) &wxDefaultSize;
      long  _arg4 = (long ) wxWANTS_CHARS;
      wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
      wxSize * _arg3 = (wxSize *) &wxDefaultSize;
      long  _arg4 = (long ) wxWANTS_CHARS;
-    char * _arg5 = (char *) wxPanelNameStr;
+    wxString * _arg5 = (wxString *) &wxPyPanelNameStr;
      PyObject * _argo0 = 0;
      wxPoint  temp;
      PyObject * _obj2 = 0;
      wxSize  temp0;
      PyObject * _obj3 = 0;
      PyObject * _argo0 = 0;
      wxPoint  temp;
      PyObject * _obj2 = 0;
      wxSize  temp0;
      PyObject * _obj3 = 0;
+    PyObject * _obj5 = 0;
      char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
      char _ptemp[128];
  
      self = self;
      char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
      char _ptemp[128];
  
      self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxGrid",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOlO:new_wxGrid",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_obj5)) 
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
@@ -7243,11 +7237,17 @@ static PyObject *_wrap_new_wxGrid(PyObject *self, PyObject *args, PyObject *kwar
      if (! wxSize_helper(_obj3, &_arg3))
          return NULL;
  }
      if (! wxSize_helper(_obj3, &_arg3))
          return NULL;
  }
+    if (_obj5)
  {
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGrid *)new_wxGrid(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
+    _arg5 = wxString_in_helper(_obj5);
+    if (_arg5 == NULL)
+        return NULL;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGrid *)new_wxGrid(_arg0,_arg1,*_arg2,*_arg3,_arg4,*_arg5);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGrid_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGrid_p");
@@ -7256,6 +7256,10 @@ static PyObject *_wrap_new_wxGrid(PyObject *self, PyObject *args, PyObject *kwar
          Py_INCREF(Py_None);
          _resultobj = Py_None;
      }
          Py_INCREF(Py_None);
          _resultobj = Py_None;
      }
+{
+    if (_obj5)
+        delete _arg5;
+}
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -7281,10 +7285,10 @@ static PyObject *_wrap_wxGrid_CreateGrid(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_CreateGrid(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_CreateGrid(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7309,10 +7313,10 @@ static PyObject *_wrap_wxGrid_SetSelectionMode(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetSelectionMode(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetSelectionMode(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7338,10 +7342,10 @@ static PyObject *_wrap_wxGrid_GetNumberRows(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetNumberRows(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetNumberRows(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7366,10 +7370,10 @@ static PyObject *_wrap_wxGrid_GetNumberCols(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetNumberCols(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetNumberCols(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7403,10 +7407,10 @@ static PyObject *_wrap_wxGrid_ProcessTableMessage(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_ProcessTableMessage(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_ProcessTableMessage(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7431,12 +7435,12 @@ static PyObject *_wrap_wxGrid_GetTable(PyObject *self, PyObject *args, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridTableBase *)wxGrid_GetTable(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridTableBase *)wxGrid_GetTable(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}{ _resultobj = wxPyMake_wxObject(_result); }
+}{ _resultobj = wxPyMake_wxGridTableBase(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -7472,10 +7476,10 @@ static PyObject *_wrap_wxGrid_SetTable(PyObject *self, PyObject *args, PyObject
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_SetTable(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_SetTable(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7499,10 +7503,10 @@ static PyObject *_wrap_wxGrid_ClearGrid(PyObject *self, PyObject *args, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_ClearGrid(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_ClearGrid(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7533,10 +7537,10 @@ static PyObject *_wrap_wxGrid_InsertRows(PyObject *self, PyObject *args, PyObjec
      }
      _arg3 = (bool ) tempbool3;
  {
      }
      _arg3 = (bool ) tempbool3;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_InsertRows(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_InsertRows(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7565,10 +7569,10 @@ static PyObject *_wrap_wxGrid_AppendRows(PyObject *self, PyObject *args, PyObjec
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_AppendRows(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_AppendRows(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7598,10 +7602,10 @@ static PyObject *_wrap_wxGrid_DeleteRows(PyObject *self, PyObject *args, PyObjec
      }
      _arg3 = (bool ) tempbool3;
  {
      }
      _arg3 = (bool ) tempbool3;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_DeleteRows(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_DeleteRows(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7631,10 +7635,10 @@ static PyObject *_wrap_wxGrid_InsertCols(PyObject *self, PyObject *args, PyObjec
      }
      _arg3 = (bool ) tempbool3;
  {
      }
      _arg3 = (bool ) tempbool3;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_InsertCols(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_InsertCols(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7663,10 +7667,10 @@ static PyObject *_wrap_wxGrid_AppendCols(PyObject *self, PyObject *args, PyObjec
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_AppendCols(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_AppendCols(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7696,10 +7700,10 @@ static PyObject *_wrap_wxGrid_DeleteCols(PyObject *self, PyObject *args, PyObjec
      }
      _arg3 = (bool ) tempbool3;
  {
      }
      _arg3 = (bool ) tempbool3;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_DeleteCols(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_DeleteCols(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -7741,10 +7745,10 @@ static PyObject *_wrap_wxGrid_DrawCellHighlight(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_DrawCellHighlight(_arg0,*_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_DrawCellHighlight(_arg0,*_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7785,22 +7789,9 @@ 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, wxStringErrorMsg);
-        return NULL;
-    }
-    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          return NULL;
-    _arg2 = new wxString(tmpPtr, tmpSize);
-#else
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
      _arg3 = &temp;
  }
  {
      _arg3 = &temp;
@@ -7808,10 +7799,10 @@ static PyObject *_wrap_wxGrid_DrawTextRectangle(PyObject *self, PyObject *args,
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_DrawTextRectangle(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_DrawTextRectangle(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7822,67 +7813,6 @@ static PyObject *_wrap_wxGrid_DrawTextRectangle(PyObject *self, PyObject *args,
      return _resultobj;
  }
  
      return _resultobj;
  }
  
-#define wxGrid_StringToLines(_swigobj,_swigarg0,_swigarg1)  (_swigobj->StringToLines(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxGrid_StringToLines(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGrid * _arg0;
-    wxString * _arg1;
-    wxArrayString * _arg2;
-    PyObject * _argo0 = 0;
-    PyObject * _obj1 = 0;
-    PyObject * _argo2 = 0;
-    char *_kwnames[] = { "self","value","lines", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_StringToLines",_kwnames,&_argo0,&_obj1,&_argo2)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_StringToLines. Expected _wxGrid_p.");
-        return NULL;
-        }
-    }
-{
-#if PYTHON_API_VERSION >= 1009
-    char* tmpPtr; int tmpSize;
-    if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        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_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
-}
-    if (_argo2) {
-        if (_argo2 == Py_None) { _arg2 = NULL; }
-        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxArrayString_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_StringToLines. Expected _wxArrayString_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_StringToLines(_arg0,*_arg1,*_arg2);
-
-    wxPy_END_ALLOW_THREADS;
-    if (PyErr_Occurred()) return NULL;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-{
-    if (_obj1)
-        delete _arg1;
-}
-    return _resultobj;
-}
-
  #define wxGrid_GetTextBoxSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetTextBoxSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
  static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
  #define wxGrid_GetTextBoxSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetTextBoxSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
  static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyObject *kwargs) {
      PyObject * _resultobj;
@@ -7895,7 +7825,7 @@ static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyO
      long  temp0;
      PyObject * _argo0 = 0;
      PyObject * _argo1 = 0;
      long  temp0;
      PyObject * _argo0 = 0;
      PyObject * _argo1 = 0;
-    PyObject * _argo2 = 0;
+    PyObject * _obj2 = 0;
      char *_kwnames[] = { "self","dc","lines", NULL };
  
      self = self;
      char *_kwnames[] = { "self","dc","lines", NULL };
  
      self = self;
@@ -7905,7 +7835,7 @@ static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyO
  {
    _arg4 = &temp0;
  }
  {
    _arg4 = &temp0;
  }
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetTextBoxSize",_kwnames,&_argo0,&_argo1,&_argo2)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetTextBoxSize",_kwnames,&_argo0,&_argo1,&_obj2)) 
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
          return NULL;
      if (_argo0) {
          if (_argo0 == Py_None) { _arg0 = NULL; }
@@ -7921,18 +7851,31 @@ static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyO
          return NULL;
          }
      }
          return NULL;
          }
      }
-    if (_argo2) {
-        if (_argo2 == Py_None) { _arg2 = NULL; }
-        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxArrayString_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_GetTextBoxSize. Expected _wxArrayString_p.");
+{
+    if (! PySequence_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
          return NULL;
          return NULL;
-        }
      }
      }
+    _arg2 = new wxArrayString;
+    int i, len=PySequence_Length(_obj2);
+    for (i=0; i<len; i++) {
+        PyObject* item = PySequence_GetItem(_obj2, i);
+#if wxUSE_UNICODE
+        PyObject* str  = PyObject_Unicode(item);
+        _arg2->Add(PyUnicode_AsUnicode(str));
+#else
+        PyObject* str  = PyObject_Str(item);
+        _arg2->Add(PyString_AsString(str));
+#endif
+        Py_DECREF(item);
+        Py_DECREF(str);
+    }
+}
  {
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_GetTextBoxSize(_arg0,*_arg1,*_arg2,_arg3,_arg4);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_GetTextBoxSize(_arg0,*_arg1,*_arg2,_arg3,_arg4);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7945,6 +7888,10 @@ static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyO
      PyObject *o;
      o = PyInt_FromLong((long) (*_arg4));
      _resultobj = t_output_helper(_resultobj, o);
      PyObject *o;
      o = PyInt_FromLong((long) (*_arg4));
      _resultobj = t_output_helper(_resultobj, o);
+}
+{
+    if (_obj2)
+        delete _arg2;
  }
      return _resultobj;
  }
  }
      return _resultobj;
  }
@@ -7967,10 +7914,10 @@ static PyObject *_wrap_wxGrid_BeginBatch(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_BeginBatch(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_BeginBatch(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -7995,10 +7942,10 @@ static PyObject *_wrap_wxGrid_EndBatch(PyObject *self, PyObject *args, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_EndBatch(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_EndBatch(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8024,10 +7971,10 @@ static PyObject *_wrap_wxGrid_GetBatchCount(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetBatchCount(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetBatchCount(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8051,10 +7998,10 @@ static PyObject *_wrap_wxGrid_ForceRefresh(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_ForceRefresh(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_ForceRefresh(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8080,10 +8027,10 @@ static PyObject *_wrap_wxGrid_IsEditable(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsEditable(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsEditable(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8110,10 +8057,10 @@ static PyObject *_wrap_wxGrid_EnableEditing(PyObject *self, PyObject *args, PyOb
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_EnableEditing(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_EnableEditing(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8141,10 +8088,10 @@ static PyObject *_wrap_wxGrid_EnableCellEditControl(PyObject *self, PyObject *ar
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_EnableCellEditControl(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_EnableCellEditControl(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8169,10 +8116,10 @@ static PyObject *_wrap_wxGrid_DisableCellEditControl(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_DisableCellEditControl(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_DisableCellEditControl(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8198,10 +8145,10 @@ static PyObject *_wrap_wxGrid_CanEnableCellControl(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_CanEnableCellControl(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_CanEnableCellControl(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8226,10 +8173,10 @@ static PyObject *_wrap_wxGrid_IsCellEditControlEnabled(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsCellEditControlEnabled(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsCellEditControlEnabled(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8254,10 +8201,10 @@ static PyObject *_wrap_wxGrid_IsCellEditControlShown(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsCellEditControlShown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsCellEditControlShown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8282,10 +8229,10 @@ static PyObject *_wrap_wxGrid_IsCurrentCellReadOnly(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsCurrentCellReadOnly(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsCurrentCellReadOnly(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8309,10 +8256,10 @@ static PyObject *_wrap_wxGrid_ShowCellEditControl(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_ShowCellEditControl(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_ShowCellEditControl(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8337,10 +8284,10 @@ static PyObject *_wrap_wxGrid_HideCellEditControl(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_HideCellEditControl(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_HideCellEditControl(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8365,10 +8312,10 @@ static PyObject *_wrap_wxGrid_SaveEditControlValue(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SaveEditControlValue(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SaveEditControlValue(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8401,10 +8348,10 @@ static PyObject *_wrap_wxGrid_XYToCell(PyObject *self, PyObject *args, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellCoords *)wxGrid_XYToCell(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellCoords *)wxGrid_XYToCell(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
@@ -8436,10 +8383,10 @@ static PyObject *_wrap_wxGrid_YToRow(PyObject *self, PyObject *args, PyObject *k
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_YToRow(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_YToRow(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8465,10 +8412,10 @@ static PyObject *_wrap_wxGrid_XToCol(PyObject *self, PyObject *args, PyObject *k
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_XToCol(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_XToCol(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8494,10 +8441,10 @@ static PyObject *_wrap_wxGrid_YToEdgeOfRow(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_YToEdgeOfRow(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_YToEdgeOfRow(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8523,10 +8470,10 @@ static PyObject *_wrap_wxGrid_XToEdgeOfCol(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_XToEdgeOfCol(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_XToEdgeOfCol(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8554,10 +8501,10 @@ static PyObject *_wrap_wxGrid_CellToRect(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxRect (wxGrid_CellToRect(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxRect (wxGrid_CellToRect(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -8583,10 +8530,10 @@ static PyObject *_wrap_wxGrid_GetGridCursorRow(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetGridCursorRow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetGridCursorRow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8611,10 +8558,10 @@ static PyObject *_wrap_wxGrid_GetGridCursorCol(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetGridCursorCol(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetGridCursorCol(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8644,10 +8591,10 @@ static PyObject *_wrap_wxGrid_IsVisible(PyObject *self, PyObject *args, PyObject
      }
      _arg3 = (bool ) tempbool3;
  {
      }
      _arg3 = (bool ) tempbool3;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsVisible(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsVisible(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8673,10 +8620,10 @@ static PyObject *_wrap_wxGrid_MakeCellVisible(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_MakeCellVisible(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_MakeCellVisible(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8703,10 +8650,10 @@ static PyObject *_wrap_wxGrid_SetGridCursor(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetGridCursor(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetGridCursor(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -8735,10 +8682,10 @@ static PyObject *_wrap_wxGrid_MoveCursorUp(PyObject *self, PyObject *args, PyObj
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorUp(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorUp(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8766,10 +8713,10 @@ static PyObject *_wrap_wxGrid_MoveCursorDown(PyObject *self, PyObject *args, PyO
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorDown(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorDown(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8797,10 +8744,10 @@ static PyObject *_wrap_wxGrid_MoveCursorLeft(PyObject *self, PyObject *args, PyO
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorLeft(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorLeft(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8828,10 +8775,10 @@ static PyObject *_wrap_wxGrid_MoveCursorRight(PyObject *self, PyObject *args, Py
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorRight(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorRight(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8856,10 +8803,10 @@ static PyObject *_wrap_wxGrid_MovePageDown(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MovePageDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MovePageDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8884,10 +8831,10 @@ static PyObject *_wrap_wxGrid_MovePageUp(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MovePageUp(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MovePageUp(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8915,10 +8862,10 @@ static PyObject *_wrap_wxGrid_MoveCursorUpBlock(PyObject *self, PyObject *args,
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorUpBlock(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorUpBlock(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8946,10 +8893,10 @@ static PyObject *_wrap_wxGrid_MoveCursorDownBlock(PyObject *self, PyObject *args
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorDownBlock(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorDownBlock(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -8977,10 +8924,10 @@ static PyObject *_wrap_wxGrid_MoveCursorLeftBlock(PyObject *self, PyObject *args
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorLeftBlock(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorLeftBlock(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9008,10 +8955,10 @@ static PyObject *_wrap_wxGrid_MoveCursorRightBlock(PyObject *self, PyObject *arg
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_MoveCursorRightBlock(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_MoveCursorRightBlock(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9036,10 +8983,10 @@ static PyObject *_wrap_wxGrid_GetDefaultRowLabelSize(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetDefaultRowLabelSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetDefaultRowLabelSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9064,10 +9011,10 @@ static PyObject *_wrap_wxGrid_GetRowLabelSize(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetRowLabelSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetRowLabelSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9092,10 +9039,10 @@ static PyObject *_wrap_wxGrid_GetDefaultColLabelSize(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetDefaultColLabelSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetDefaultColLabelSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9120,10 +9067,10 @@ static PyObject *_wrap_wxGrid_GetColLabelSize(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetColLabelSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetColLabelSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9149,10 +9096,10 @@ static PyObject *_wrap_wxGrid_GetLabelBackgroundColour(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetLabelBackgroundColour(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetLabelBackgroundColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -9179,10 +9126,10 @@ static PyObject *_wrap_wxGrid_GetLabelTextColour(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetLabelTextColour(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetLabelTextColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -9209,10 +9156,10 @@ static PyObject *_wrap_wxGrid_GetLabelFont(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxFont (wxGrid_GetLabelFont(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxFont (wxGrid_GetLabelFont(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -9247,10 +9194,10 @@ static PyObject *_wrap_wxGrid_GetRowLabelAlignment(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_GetRowLabelAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_GetRowLabelAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9295,10 +9242,10 @@ static PyObject *_wrap_wxGrid_GetColLabelAlignment(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_GetColLabelAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_GetColLabelAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9335,13 +9282,17 @@ static PyObject *_wrap_wxGrid_GetRowLabelValue(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxGrid_GetRowLabelValue(_arg0,_arg1));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxGrid_GetRowLabelValue(_arg0,_arg1));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -9369,13 +9320,17 @@ static PyObject *_wrap_wxGrid_GetColLabelValue(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxGrid_GetColLabelValue(_arg0,_arg1));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxGrid_GetColLabelValue(_arg0,_arg1));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -9403,10 +9358,10 @@ static PyObject *_wrap_wxGrid_GetGridLineColour(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetGridLineColour(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetGridLineColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -9433,10 +9388,10 @@ static PyObject *_wrap_wxGrid_GetCellHighlightColour(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetCellHighlightColour(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetCellHighlightColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -9462,10 +9417,10 @@ static PyObject *_wrap_wxGrid_GetCellHighlightPenWidth(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetCellHighlightPenWidth(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetCellHighlightPenWidth(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9490,10 +9445,10 @@ static PyObject *_wrap_wxGrid_GetCellHighlightROPenWidth(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetCellHighlightROPenWidth(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetCellHighlightROPenWidth(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -9518,10 +9473,10 @@ static PyObject *_wrap_wxGrid_SetRowLabelSize(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetRowLabelSize(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetRowLabelSize(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9547,10 +9502,10 @@ static PyObject *_wrap_wxGrid_SetColLabelSize(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColLabelSize(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColLabelSize(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9583,10 +9538,10 @@ static PyObject *_wrap_wxGrid_SetLabelBackgroundColour(PyObject *self, PyObject
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetLabelBackgroundColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetLabelBackgroundColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9619,10 +9574,10 @@ static PyObject *_wrap_wxGrid_SetLabelTextColour(PyObject *self, PyObject *args,
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetLabelTextColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetLabelTextColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9656,10 +9611,10 @@ static PyObject *_wrap_wxGrid_SetLabelFont(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetLabelFont(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetLabelFont(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9686,10 +9641,10 @@ static PyObject *_wrap_wxGrid_SetRowLabelAlignment(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetRowLabelAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetRowLabelAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9716,10 +9671,10 @@ static PyObject *_wrap_wxGrid_SetColLabelAlignment(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColLabelAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColLabelAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9747,28 +9702,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetRowLabelValue(_arg0,_arg1,*_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetRowLabelValue(_arg0,_arg1,*_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9800,28 +9742,15 @@ 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, wxStringErrorMsg);
-        return NULL;
-    }
-    if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          return NULL;
-    _arg2 = new wxString(tmpPtr, tmpSize);
-#else
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColLabelValue(_arg0,_arg1,*_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColLabelValue(_arg0,_arg1,*_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9858,10 +9787,10 @@ static PyObject *_wrap_wxGrid_SetGridLineColour(PyObject *self, PyObject *args,
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetGridLineColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetGridLineColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9894,10 +9823,10 @@ static PyObject *_wrap_wxGrid_SetCellHighlightColour(PyObject *self, PyObject *a
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellHighlightColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellHighlightColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9923,10 +9852,10 @@ static PyObject *_wrap_wxGrid_SetCellHighlightPenWidth(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellHighlightPenWidth(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellHighlightPenWidth(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9952,10 +9881,10 @@ static PyObject *_wrap_wxGrid_SetCellHighlightROPenWidth(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellHighlightROPenWidth(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellHighlightROPenWidth(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -9983,10 +9912,10 @@ static PyObject *_wrap_wxGrid_EnableDragRowSize(PyObject *self, PyObject *args,
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_EnableDragRowSize(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_EnableDragRowSize(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10011,10 +9940,10 @@ static PyObject *_wrap_wxGrid_DisableDragRowSize(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_DisableDragRowSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_DisableDragRowSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10040,10 +9969,10 @@ static PyObject *_wrap_wxGrid_CanDragRowSize(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_CanDragRowSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_CanDragRowSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10070,10 +9999,10 @@ static PyObject *_wrap_wxGrid_EnableDragColSize(PyObject *self, PyObject *args,
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_EnableDragColSize(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_EnableDragColSize(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10098,10 +10027,10 @@ static PyObject *_wrap_wxGrid_DisableDragColSize(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_DisableDragColSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_DisableDragColSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10127,10 +10056,10 @@ static PyObject *_wrap_wxGrid_CanDragColSize(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_CanDragColSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_CanDragColSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10157,10 +10086,10 @@ static PyObject *_wrap_wxGrid_EnableDragGridSize(PyObject *self, PyObject *args,
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_EnableDragGridSize(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_EnableDragGridSize(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10185,10 +10114,10 @@ static PyObject *_wrap_wxGrid_DisableDragGridSize(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_DisableDragGridSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_DisableDragGridSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10214,10 +10143,10 @@ static PyObject *_wrap_wxGrid_CanDragGridSize(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_CanDragGridSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_CanDragGridSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10251,10 +10180,10 @@ static PyObject *_wrap_wxGrid_SetRowAttr(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetRowAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetRowAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10289,10 +10218,10 @@ static PyObject *_wrap_wxGrid_SetColAttr(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColAttr(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColAttr(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10318,10 +10247,10 @@ static PyObject *_wrap_wxGrid_SetColFormatBool(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColFormatBool(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColFormatBool(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10347,10 +10276,10 @@ static PyObject *_wrap_wxGrid_SetColFormatNumber(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColFormatNumber(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColFormatNumber(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10378,10 +10307,10 @@ static PyObject *_wrap_wxGrid_SetColFormatFloat(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColFormatFloat(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColFormatFloat(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10409,28 +10338,15 @@ 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, wxStringErrorMsg);
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
          return NULL;
          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_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColFormatCustom(_arg0,_arg1,*_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColFormatCustom(_arg0,_arg1,*_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10462,10 +10378,10 @@ static PyObject *_wrap_wxGrid_EnableGridLines(PyObject *self, PyObject *args, Py
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_EnableGridLines(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_EnableGridLines(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10491,10 +10407,10 @@ static PyObject *_wrap_wxGrid_GridLinesEnabled(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_GridLinesEnabled(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_GridLinesEnabled(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10519,10 +10435,10 @@ static PyObject *_wrap_wxGrid_GetDefaultRowSize(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetDefaultRowSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetDefaultRowSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10548,10 +10464,10 @@ static PyObject *_wrap_wxGrid_GetRowSize(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetRowSize(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetRowSize(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10576,10 +10492,10 @@ static PyObject *_wrap_wxGrid_GetDefaultColSize(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetDefaultColSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetDefaultColSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10605,10 +10521,10 @@ static PyObject *_wrap_wxGrid_GetColSize(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGrid_GetColSize(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGrid_GetColSize(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -10634,10 +10550,10 @@ static PyObject *_wrap_wxGrid_GetDefaultCellBackgroundColour(PyObject *self, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetDefaultCellBackgroundColour(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetDefaultCellBackgroundColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -10666,10 +10582,10 @@ static PyObject *_wrap_wxGrid_GetCellBackgroundColour(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetCellBackgroundColour(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetCellBackgroundColour(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -10696,10 +10612,10 @@ static PyObject *_wrap_wxGrid_GetDefaultCellTextColour(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetDefaultCellTextColour(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetDefaultCellTextColour(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -10728,10 +10644,10 @@ static PyObject *_wrap_wxGrid_GetCellTextColour(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetCellTextColour(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetCellTextColour(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -10758,10 +10674,10 @@ static PyObject *_wrap_wxGrid_GetDefaultCellFont(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxFont (wxGrid_GetDefaultCellFont(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxFont (wxGrid_GetDefaultCellFont(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -10790,10 +10706,10 @@ static PyObject *_wrap_wxGrid_GetCellFont(PyObject *self, PyObject *args, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxFont (wxGrid_GetCellFont(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxFont (wxGrid_GetCellFont(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -10836,10 +10752,10 @@ static PyObject *_wrap_wxGrid_GetDefaultCellAlignment(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_GetDefaultCellAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_GetDefaultCellAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10884,10 +10800,10 @@ static PyObject *_wrap_wxGrid_GetCellAlignment(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_GetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_GetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10916,10 +10832,10 @@ static PyObject *_wrap_wxGrid_SetDefaultRowSize(PyObject *self, PyObject *args,
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultRowSize(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultRowSize(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10946,10 +10862,10 @@ static PyObject *_wrap_wxGrid_SetRowSize(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetRowSize(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetRowSize(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -10978,10 +10894,10 @@ static PyObject *_wrap_wxGrid_SetDefaultColSize(PyObject *self, PyObject *args,
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultColSize(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultColSize(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11008,10 +10924,10 @@ static PyObject *_wrap_wxGrid_SetColSize(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColSize(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColSize(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11040,10 +10956,10 @@ static PyObject *_wrap_wxGrid_AutoSizeColumn(PyObject *self, PyObject *args, PyO
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_AutoSizeColumn(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_AutoSizeColumn(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11072,10 +10988,10 @@ static PyObject *_wrap_wxGrid_AutoSizeRow(PyObject *self, PyObject *args, PyObje
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_AutoSizeRow(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_AutoSizeRow(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11103,10 +11019,10 @@ static PyObject *_wrap_wxGrid_AutoSizeColumns(PyObject *self, PyObject *args, Py
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_AutoSizeColumns(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_AutoSizeColumns(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11134,10 +11050,10 @@ static PyObject *_wrap_wxGrid_AutoSizeRows(PyObject *self, PyObject *args, PyObj
      }
      _arg1 = (bool ) tempbool1;
  {
      }
      _arg1 = (bool ) tempbool1;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_AutoSizeRows(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_AutoSizeRows(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11162,10 +11078,10 @@ static PyObject *_wrap_wxGrid_AutoSize(PyObject *self, PyObject *args, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_AutoSize(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_AutoSize(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11192,10 +11108,10 @@ static PyObject *_wrap_wxGrid_SetColMinimalWidth(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetColMinimalWidth(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetColMinimalWidth(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11222,10 +11138,10 @@ static PyObject *_wrap_wxGrid_SetRowMinimalHeight(PyObject *self, PyObject *args
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetRowMinimalHeight(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetRowMinimalHeight(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11258,10 +11174,10 @@ static PyObject *_wrap_wxGrid_SetDefaultCellBackgroundColour(PyObject *self, PyO
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultCellBackgroundColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultCellBackgroundColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11296,10 +11212,10 @@ static PyObject *_wrap_wxGrid_SetCellBackgroundColour(PyObject *self, PyObject *
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellBackgroundColour(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellBackgroundColour(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11332,10 +11248,10 @@ static PyObject *_wrap_wxGrid_SetDefaultCellTextColour(PyObject *self, PyObject
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultCellTextColour(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultCellTextColour(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11370,10 +11286,10 @@ static PyObject *_wrap_wxGrid_SetCellTextColour(PyObject *self, PyObject *args,
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellTextColour(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellTextColour(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11407,10 +11323,10 @@ static PyObject *_wrap_wxGrid_SetDefaultCellFont(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultCellFont(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultCellFont(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11446,10 +11362,10 @@ static PyObject *_wrap_wxGrid_SetCellFont(PyObject *self, PyObject *args, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellFont(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellFont(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11476,10 +11392,10 @@ static PyObject *_wrap_wxGrid_SetDefaultCellAlignment(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultCellAlignment(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultCellAlignment(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11508,10 +11424,10 @@ static PyObject *_wrap_wxGrid_SetCellAlignment(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11545,10 +11461,10 @@ static PyObject *_wrap_wxGrid_SetDefaultRenderer(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultRenderer(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultRenderer(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11584,10 +11500,10 @@ static PyObject *_wrap_wxGrid_SetCellRenderer(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellRenderer(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellRenderer(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11601,7 +11517,6 @@ static PyObject *_wrap_wxGrid_GetDefaultRenderer(PyObject *self, PyObject *args,
      wxGrid * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
      wxGrid * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRenderer",_kwnames,&_argo0)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRenderer",_kwnames,&_argo0)) 
@@ -11614,18 +11529,12 @@ static PyObject *_wrap_wxGrid_GetDefaultRenderer(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellRenderer *)wxGrid_GetDefaultRenderer(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellRenderer *)wxGrid_GetDefaultRenderer(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellRenderer(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -11638,7 +11547,6 @@ static PyObject *_wrap_wxGrid_GetCellRenderer(PyObject *self, PyObject *args, Py
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2)) 
@@ -11651,18 +11559,12 @@ static PyObject *_wrap_wxGrid_GetCellRenderer(PyObject *self, PyObject *args, Py
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellRenderer *)wxGrid_GetCellRenderer(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellRenderer *)wxGrid_GetCellRenderer(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellRenderer(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -11693,10 +11595,10 @@ static PyObject *_wrap_wxGrid_SetDefaultEditor(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetDefaultEditor(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetDefaultEditor(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11732,10 +11634,10 @@ static PyObject *_wrap_wxGrid_SetCellEditor(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellEditor(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellEditor(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11749,7 +11651,6 @@ static PyObject *_wrap_wxGrid_GetDefaultEditor(PyObject *self, PyObject *args, P
      wxGrid * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
      wxGrid * _arg0;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultEditor",_kwnames,&_argo0)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultEditor",_kwnames,&_argo0)) 
@@ -11762,18 +11663,12 @@ static PyObject *_wrap_wxGrid_GetDefaultEditor(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEditor *)wxGrid_GetDefaultEditor(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEditor *)wxGrid_GetDefaultEditor(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellEditor(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -11786,7 +11681,6 @@ static PyObject *_wrap_wxGrid_GetCellEditor(PyObject *self, PyObject *args, PyOb
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2)) 
@@ -11799,18 +11693,12 @@ static PyObject *_wrap_wxGrid_GetCellEditor(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEditor *)wxGrid_GetCellEditor(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEditor *)wxGrid_GetCellEditor(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellEditor(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -11835,13 +11723,17 @@ static PyObject *_wrap_wxGrid_GetCellValue(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxString (wxGrid_GetCellValue(_arg0,_arg1,_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxString (wxGrid_GetCellValue(_arg0,_arg1,_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{
      if (PyErr_Occurred()) return NULL;
  }{
+#if wxUSE_UNICODE
+    _resultobj = PyUnicode_FromUnicode(_result->c_str(), _result->Len());
+#else
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
      _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
+#endif
  }
  {
      delete _result;
  }
  {
      delete _result;
@@ -11871,28 +11763,15 @@ 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, wxStringErrorMsg);
-        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);
+    _arg3 = wxString_in_helper(_obj3);
+    if (_arg3 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetCellValue(_arg0,_arg1,_arg2,*_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetCellValue(_arg0,_arg1,_arg2,*_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11924,10 +11803,10 @@ static PyObject *_wrap_wxGrid_IsReadOnly(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsReadOnly(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsReadOnly(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -11956,10 +11835,10 @@ static PyObject *_wrap_wxGrid_SetReadOnly(PyObject *self, PyObject *args, PyObje
      }
      _arg3 = (bool ) tempbool3;
  {
      }
      _arg3 = (bool ) tempbool3;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetReadOnly(_arg0,_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetReadOnly(_arg0,_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -11988,10 +11867,10 @@ static PyObject *_wrap_wxGrid_SelectRow(PyObject *self, PyObject *args, PyObject
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SelectRow(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SelectRow(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12020,10 +11899,10 @@ static PyObject *_wrap_wxGrid_SelectCol(PyObject *self, PyObject *args, PyObject
      }
      _arg2 = (bool ) tempbool2;
  {
      }
      _arg2 = (bool ) tempbool2;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SelectCol(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SelectCol(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12055,10 +11934,10 @@ static PyObject *_wrap_wxGrid_SelectBlock(PyObject *self, PyObject *args, PyObje
      }
      _arg5 = (bool ) tempbool5;
  {
      }
      _arg5 = (bool ) tempbool5;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SelectBlock(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SelectBlock(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12083,10 +11962,10 @@ static PyObject *_wrap_wxGrid_SelectAll(PyObject *self, PyObject *args, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SelectAll(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SelectAll(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12112,10 +11991,10 @@ static PyObject *_wrap_wxGrid_IsSelection(PyObject *self, PyObject *args, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsSelection(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsSelection(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -12139,10 +12018,10 @@ static PyObject *_wrap_wxGrid_ClearSelection(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_ClearSelection(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_ClearSelection(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12170,10 +12049,10 @@ static PyObject *_wrap_wxGrid_IsInSelection(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGrid_IsInSelection(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGrid_IsInSelection(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -12215,10 +12094,10 @@ static PyObject *_wrap_wxGrid_BlockToDeviceRect(PyObject *self, PyObject *args,
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxRect (wxGrid_BlockToDeviceRect(_arg0,*_arg1,*_arg2));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxRect (wxGrid_BlockToDeviceRect(_arg0,*_arg1,*_arg2));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -12245,10 +12124,10 @@ static PyObject *_wrap_wxGrid_GetSelectionBackground(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetSelectionBackground(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetSelectionBackground(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -12275,10 +12154,10 @@ static PyObject *_wrap_wxGrid_GetSelectionForeground(PyObject *self, PyObject *a
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxColour (wxGrid_GetSelectionForeground(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxColour (wxGrid_GetSelectionForeground(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -12311,10 +12190,10 @@ static PyObject *_wrap_wxGrid_SetSelectionBackground(PyObject *self, PyObject *a
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetSelectionBackground(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetSelectionBackground(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12347,10 +12226,10 @@ static PyObject *_wrap_wxGrid_SetSelectionForeground(PyObject *self, PyObject *a
          return NULL;
  }
  {
          return NULL;
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetSelectionForeground(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetSelectionForeground(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12381,22 +12260,9 @@ 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, wxStringErrorMsg);
-        return NULL;
-    }
-    if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          return NULL;
-    _arg1 = new wxString(tmpPtr, tmpSize);
-#else
-    if (!PyString_Check(_obj1)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
      if (_argo2) {
          if (_argo2 == Py_None) { _arg2 = NULL; }
  }
      if (_argo2) {
          if (_argo2 == Py_None) { _arg2 = NULL; }
@@ -12413,10 +12279,10 @@ static PyObject *_wrap_wxGrid_RegisterDataType(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_RegisterDataType(_arg0,*_arg1,_arg2,_arg3);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_RegisterDataType(_arg0,*_arg1,_arg2,_arg3);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12436,7 +12302,6 @@ static PyObject *_wrap_wxGrid_GetDefaultEditorForCell(PyObject *self, PyObject *
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultEditorForCell",_kwnames,&_argo0,&_arg1,&_arg2)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultEditorForCell",_kwnames,&_argo0,&_arg1,&_arg2)) 
@@ -12449,18 +12314,12 @@ static PyObject *_wrap_wxGrid_GetDefaultEditorForCell(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForCell(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForCell(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellEditor(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -12473,7 +12332,6 @@ static PyObject *_wrap_wxGrid_GetDefaultRendererForCell(PyObject *self, PyObject
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
      int  _arg2;
      PyObject * _argo0 = 0;
      char *_kwnames[] = { "self","row","col", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultRendererForCell",_kwnames,&_argo0,&_arg1,&_arg2)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultRendererForCell",_kwnames,&_argo0,&_arg1,&_arg2)) 
@@ -12486,18 +12344,12 @@ static PyObject *_wrap_wxGrid_GetDefaultRendererForCell(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForCell(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForCell(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellRenderer(_result); }
      return _resultobj;
  }
  
      return _resultobj;
  }
  
@@ -12510,7 +12362,6 @@ static PyObject *_wrap_wxGrid_GetDefaultEditorForType(PyObject *self, PyObject *
      PyObject * _argo0 = 0;
      PyObject * _obj1 = 0;
      char *_kwnames[] = { "self","typeName", NULL };
      PyObject * _argo0 = 0;
      PyObject * _obj1 = 0;
      char *_kwnames[] = { "self","typeName", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultEditorForType",_kwnames,&_argo0,&_obj1)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultEditorForType",_kwnames,&_argo0,&_obj1)) 
@@ -12523,36 +12374,17 @@ 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, wxStringErrorMsg);
-        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);
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForType(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForType(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellEditor(_result); }
  {
      if (_obj1)
          delete _arg1;
  {
      if (_obj1)
          delete _arg1;
@@ -12569,7 +12401,6 @@ static PyObject *_wrap_wxGrid_GetDefaultRendererForType(PyObject *self, PyObject
      PyObject * _argo0 = 0;
      PyObject * _obj1 = 0;
      char *_kwnames[] = { "self","typeName", NULL };
      PyObject * _argo0 = 0;
      PyObject * _obj1 = 0;
      char *_kwnames[] = { "self","typeName", NULL };
-    char _ptemp[128];
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultRendererForType",_kwnames,&_argo0,&_obj1)) 
  
      self = self;
      if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultRendererForType",_kwnames,&_argo0,&_obj1)) 
@@ -12582,36 +12413,17 @@ 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, wxStringErrorMsg);
-        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);
+    _arg1 = wxString_in_helper(_obj1);
+    if (_arg1 == NULL)
          return NULL;
          return NULL;
-    }
-    _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
-#endif
  }
  {
  }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForType(_arg0,*_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForType(_arg0,*_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
      if (PyErr_Occurred()) return NULL;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
+}{ _resultobj = wxPyMake_wxGridCellRenderer(_result); }
  {
      if (_obj1)
          delete _arg1;
  {
      if (_obj1)
          delete _arg1;
@@ -12639,10 +12451,10 @@ static PyObject *_wrap_wxGrid_SetMargins(PyObject *self, PyObject *args, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGrid_SetMargins(_arg0,_arg1,_arg2);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGrid_SetMargins(_arg0,_arg1,_arg2);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -12668,10 +12480,10 @@ static PyObject *_wrap_wxGrid_GetGridWindow(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxWindow *)wxGrid_GetGridWindow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWindow *)wxGrid_GetGridWindow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
@@ -12696,10 +12508,10 @@ static PyObject *_wrap_wxGrid_GetGridRowLabelWindow(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxWindow *)wxGrid_GetGridRowLabelWindow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWindow *)wxGrid_GetGridRowLabelWindow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
@@ -12724,10 +12536,10 @@ static PyObject *_wrap_wxGrid_GetGridColLabelWindow(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxWindow *)wxGrid_GetGridColLabelWindow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWindow *)wxGrid_GetGridColLabelWindow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
@@ -12752,10 +12564,10 @@ static PyObject *_wrap_wxGrid_GetGridCornerLabelWindow(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxWindow *)wxGrid_GetGridCornerLabelWindow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWindow *)wxGrid_GetGridCornerLabelWindow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
@@ -12834,10 +12646,10 @@ static PyObject *_wrap_new_wxGridEvent(PyObject *self, PyObject *args, PyObject
      _arg10 = (bool ) tempbool10;
      _arg11 = (bool ) tempbool11;
  {
      _arg10 = (bool ) tempbool10;
      _arg11 = (bool ) tempbool11;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridEvent *)new_wxGridEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9,_arg10,_arg11);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridEvent *)new_wxGridEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9,_arg10,_arg11);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEvent_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEvent_p");
@@ -12868,10 +12680,10 @@ static PyObject *_wrap_wxGridEvent_GetRow(PyObject *self, PyObject *args, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridEvent_GetRow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridEvent_GetRow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -12896,10 +12708,10 @@ static PyObject *_wrap_wxGridEvent_GetCol(PyObject *self, PyObject *args, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridEvent_GetCol(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridEvent_GetCol(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -12925,10 +12737,10 @@ static PyObject *_wrap_wxGridEvent_GetPosition(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxPoint (wxGridEvent_GetPosition(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxPoint (wxGridEvent_GetPosition(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -12954,10 +12766,10 @@ static PyObject *_wrap_wxGridEvent_Selecting(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridEvent_Selecting(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridEvent_Selecting(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -12982,10 +12794,10 @@ static PyObject *_wrap_wxGridEvent_ControlDown(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridEvent_ControlDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridEvent_ControlDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13010,10 +12822,10 @@ static PyObject *_wrap_wxGridEvent_MetaDown(PyObject *self, PyObject *args, PyOb
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridEvent_MetaDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridEvent_MetaDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13038,10 +12850,10 @@ static PyObject *_wrap_wxGridEvent_ShiftDown(PyObject *self, PyObject *args, PyO
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridEvent_ShiftDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridEvent_ShiftDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13066,10 +12878,10 @@ static PyObject *_wrap_wxGridEvent_AltDown(PyObject *self, PyObject *args, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridEvent_AltDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridEvent_AltDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13144,10 +12956,10 @@ static PyObject *_wrap_new_wxGridSizeEvent(PyObject *self, PyObject *args, PyObj
      _arg8 = (bool ) tempbool8;
      _arg9 = (bool ) tempbool9;
  {
      _arg8 = (bool ) tempbool8;
      _arg9 = (bool ) tempbool9;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridSizeEvent *)new_wxGridSizeEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridSizeEvent *)new_wxGridSizeEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridSizeEvent_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridSizeEvent_p");
@@ -13178,10 +12990,10 @@ static PyObject *_wrap_wxGridSizeEvent_GetRowOrCol(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridSizeEvent_GetRowOrCol(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridSizeEvent_GetRowOrCol(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13207,10 +13019,10 @@ static PyObject *_wrap_wxGridSizeEvent_GetPosition(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxPoint (wxGridSizeEvent_GetPosition(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxPoint (wxGridSizeEvent_GetPosition(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -13236,10 +13048,10 @@ static PyObject *_wrap_wxGridSizeEvent_ControlDown(PyObject *self, PyObject *arg
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridSizeEvent_ControlDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridSizeEvent_ControlDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13264,10 +13076,10 @@ static PyObject *_wrap_wxGridSizeEvent_MetaDown(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridSizeEvent_MetaDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridSizeEvent_MetaDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13292,10 +13104,10 @@ static PyObject *_wrap_wxGridSizeEvent_ShiftDown(PyObject *self, PyObject *args,
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridSizeEvent_ShiftDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridSizeEvent_ShiftDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13320,10 +13132,10 @@ static PyObject *_wrap_wxGridSizeEvent_AltDown(PyObject *self, PyObject *args, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridSizeEvent_AltDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridSizeEvent_AltDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13414,10 +13226,10 @@ static PyObject *_wrap_new_wxGridRangeSelectEvent(PyObject *self, PyObject *args
      _arg8 = (bool ) tempbool8;
      _arg9 = (bool ) tempbool9;
  {
      _arg8 = (bool ) tempbool8;
      _arg9 = (bool ) tempbool9;
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridRangeSelectEvent *)new_wxGridRangeSelectEvent(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridRangeSelectEvent *)new_wxGridRangeSelectEvent(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridRangeSelectEvent_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridRangeSelectEvent_p");
@@ -13449,10 +13261,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_GetTopLeftCoords(PyObject *self, P
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetTopLeftCoords(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetTopLeftCoords(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -13479,10 +13291,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRightCoords(PyObject *sel
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetBottomRightCoords(_arg0));
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetBottomRightCoords(_arg0));
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
      _resultobj = Py_BuildValue("s",_ptemp);
      if (PyErr_Occurred()) return NULL;
  }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
      _resultobj = Py_BuildValue("s",_ptemp);
@@ -13508,10 +13320,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_GetTopRow(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridRangeSelectEvent_GetTopRow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridRangeSelectEvent_GetTopRow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13536,10 +13348,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRow(PyObject *self, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridRangeSelectEvent_GetBottomRow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridRangeSelectEvent_GetBottomRow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13564,10 +13376,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_GetLeftCol(PyObject *self, PyObjec
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridRangeSelectEvent_GetLeftCol(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridRangeSelectEvent_GetLeftCol(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13592,10 +13404,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_GetRightCol(PyObject *self, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridRangeSelectEvent_GetRightCol(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridRangeSelectEvent_GetRightCol(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13620,10 +13432,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_Selecting(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridRangeSelectEvent_Selecting(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridRangeSelectEvent_Selecting(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13648,10 +13460,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_ControlDown(PyObject *self, PyObje
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridRangeSelectEvent_ControlDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridRangeSelectEvent_ControlDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13676,10 +13488,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_MetaDown(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridRangeSelectEvent_MetaDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridRangeSelectEvent_MetaDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13704,10 +13516,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_ShiftDown(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridRangeSelectEvent_ShiftDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridRangeSelectEvent_ShiftDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13732,10 +13544,10 @@ static PyObject *_wrap_wxGridRangeSelectEvent_AltDown(PyObject *self, PyObject *
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (bool )wxGridRangeSelectEvent_AltDown(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxGridRangeSelectEvent_AltDown(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13798,10 +13610,10 @@ static PyObject *_wrap_new_wxGridEditorCreatedEvent(PyObject *self, PyObject *ar
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGridEditorCreatedEvent *)new_wxGridEditorCreatedEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxGridEditorCreatedEvent *)new_wxGridEditorCreatedEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEditorCreatedEvent_p");
      if (PyErr_Occurred()) return NULL;
  }    if (_result) {
          SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEditorCreatedEvent_p");
@@ -13832,10 +13644,10 @@ static PyObject *_wrap_wxGridEditorCreatedEvent_GetRow(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridEditorCreatedEvent_GetRow(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridEditorCreatedEvent_GetRow(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13860,10 +13672,10 @@ static PyObject *_wrap_wxGridEditorCreatedEvent_GetCol(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (int )wxGridEditorCreatedEvent_GetCol(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (int )wxGridEditorCreatedEvent_GetCol(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }    _resultobj = Py_BuildValue("i",_result);
      return _resultobj;
@@ -13888,10 +13700,10 @@ static PyObject *_wrap_wxGridEditorCreatedEvent_GetControl(PyObject *self, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxControl *)wxGridEditorCreatedEvent_GetControl(_arg0);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxControl *)wxGridEditorCreatedEvent_GetControl(_arg0);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
      if (PyErr_Occurred()) return NULL;
  }{ _resultobj = wxPyMake_wxObject(_result); }
      return _resultobj;
@@ -13916,10 +13728,10 @@ static PyObject *_wrap_wxGridEditorCreatedEvent_SetRow(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridEditorCreatedEvent_SetRow(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridEditorCreatedEvent_SetRow(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -13945,10 +13757,10 @@ static PyObject *_wrap_wxGridEditorCreatedEvent_SetCol(PyObject *self, PyObject
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridEditorCreatedEvent_SetCol(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridEditorCreatedEvent_SetCol(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -13982,10 +13794,10 @@ static PyObject *_wrap_wxGridEditorCreatedEvent_SetControl(PyObject *self, PyObj
          }
      }
  {
          }
      }
  {
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGridEditorCreatedEvent_SetControl(_arg0,_arg1);
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxGridEditorCreatedEvent_SetControl(_arg0,_arg1);
  
  
-    wxPy_END_ALLOW_THREADS;
+    wxPyEndAllowThreads(__tstate);
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
      if (PyErr_Occurred()) return NULL;
  }    Py_INCREF(Py_None);
      _resultobj = Py_None;
@@ -14175,7 +13987,6 @@ static PyMethodDef gridcMethods[] = {
          { "wxGrid_EndBatch", (PyCFunction) _wrap_wxGrid_EndBatch, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_BeginBatch", (PyCFunction) _wrap_wxGrid_BeginBatch, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_GetTextBoxSize", (PyCFunction) _wrap_wxGrid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_EndBatch", (PyCFunction) _wrap_wxGrid_EndBatch, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_BeginBatch", (PyCFunction) _wrap_wxGrid_BeginBatch, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_GetTextBoxSize", (PyCFunction) _wrap_wxGrid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS },
-        { "wxGrid_StringToLines", (PyCFunction) _wrap_wxGrid_StringToLines, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_DrawTextRectangle", (PyCFunction) _wrap_wxGrid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_DrawCellHighlight", (PyCFunction) _wrap_wxGrid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_DeleteCols", (PyCFunction) _wrap_wxGrid_DeleteCols, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_DrawTextRectangle", (PyCFunction) _wrap_wxGrid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_DrawCellHighlight", (PyCFunction) _wrap_wxGrid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS },
          { "wxGrid_DeleteCols", (PyCFunction) _wrap_wxGrid_DeleteCols, METH_VARARGS | METH_KEYWORDS },
@@ -14233,7 +14044,7 @@ static PyMethodDef gridcMethods[] = {
          { "wxPyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_wxPyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridTableBase_Destroy", (PyCFunction) _wrap_wxPyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_wxPyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridTableBase_Destroy", (PyCFunction) _wrap_wxPyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS },
-        { "wxPyGridTableBase__setSelf", (PyCFunction) _wrap_wxPyGridTableBase__setSelf, METH_VARARGS | METH_KEYWORDS },
+        { "wxPyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_wxPyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridTableBase", (PyCFunction) _wrap_new_wxPyGridTableBase, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_SetColAttr", (PyCFunction) _wrap_wxGridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_SetRowAttr", (PyCFunction) _wrap_wxGridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridTableBase", (PyCFunction) _wrap_new_wxPyGridTableBase, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_SetColAttr", (PyCFunction) _wrap_wxGridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_SetRowAttr", (PyCFunction) _wrap_wxGridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
@@ -14269,11 +14080,12 @@ static PyMethodDef gridcMethods[] = {
          { "wxGridTableBase_SetView", (PyCFunction) _wrap_wxGridTableBase_SetView, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_GetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_SetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_SetView", (PyCFunction) _wrap_wxGridTableBase_SetView, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_GetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS },
          { "wxGridTableBase_SetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS },
+        { "wxGridTableBase__setOORInfo", (PyCFunction) _wrap_wxGridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
-        { "wxPyGridCellAttrProvider__setSelf", (PyCFunction) _wrap_wxPyGridCellAttrProvider__setSelf, METH_VARARGS | METH_KEYWORDS },
+        { "wxPyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridCellAttrProvider", (PyCFunction) _wrap_new_wxPyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridCellAttrProvider", (PyCFunction) _wrap_new_wxPyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS },
@@ -14281,6 +14093,7 @@ static PyMethodDef gridcMethods[] = {
          { "wxGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS },
+        { "wxGridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_wxGridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAttrProvider", (PyCFunction) _wrap_new_wxGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttr_SetDefAttr", (PyCFunction) _wrap_wxGridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttr_IsReadOnly", (PyCFunction) _wrap_wxGridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAttrProvider", (PyCFunction) _wrap_new_wxGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttr_SetDefAttr", (PyCFunction) _wrap_wxGridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttr_IsReadOnly", (PyCFunction) _wrap_wxGridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
@@ -14310,6 +14123,7 @@ static PyMethodDef gridcMethods[] = {
          { "wxGridCellAttr_MergeWith", (PyCFunction) _wrap_wxGridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttr_Clone", (PyCFunction) _wrap_wxGridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAttr", (PyCFunction) _wrap_new_wxGridCellAttr, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttr_MergeWith", (PyCFunction) _wrap_wxGridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellAttr_Clone", (PyCFunction) _wrap_wxGridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAttr", (PyCFunction) _wrap_new_wxGridCellAttr, METH_VARARGS | METH_KEYWORDS },
+        { "wxGridCellAttr__setOORInfo", (PyCFunction) _wrap_wxGridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellEnumEditor", (PyCFunction) _wrap_new_wxGridCellEnumEditor, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellChoiceEditor", (PyCFunction) _wrap_new_wxGridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellEnumEditor", (PyCFunction) _wrap_new_wxGridCellEnumEditor, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellChoiceEditor", (PyCFunction) _wrap_new_wxGridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS },
@@ -14326,7 +14140,7 @@ static PyMethodDef gridcMethods[] = {
          { "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 },
          { "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 },
-        { "wxPyGridCellEditor__setSelf", (PyCFunction) _wrap_wxPyGridCellEditor__setSelf, METH_VARARGS | METH_KEYWORDS },
+        { "wxPyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridCellEditor", (PyCFunction) _wrap_new_wxPyGridCellEditor, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_Destroy", (PyCFunction) _wrap_wxGridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_HandleReturn", (PyCFunction) _wrap_wxGridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridCellEditor", (PyCFunction) _wrap_new_wxPyGridCellEditor, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_Destroy", (PyCFunction) _wrap_wxGridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_HandleReturn", (PyCFunction) _wrap_wxGridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS },
@@ -14347,6 +14161,7 @@ static PyMethodDef gridcMethods[] = {
          { "wxGridCellEditor_SetControl", (PyCFunction) _wrap_wxGridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_GetControl", (PyCFunction) _wrap_wxGridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_IsCreated", (PyCFunction) _wrap_wxGridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_SetControl", (PyCFunction) _wrap_wxGridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_GetControl", (PyCFunction) _wrap_wxGridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellEditor_IsCreated", (PyCFunction) _wrap_wxGridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS },
+        { "wxGridCellEditor__setOORInfo", (PyCFunction) _wrap_wxGridCellEditor__setOORInfo, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellEnumRenderer", (PyCFunction) _wrap_new_wxGridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellDateTimeRenderer", (PyCFunction) _wrap_new_wxGridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellEnumRenderer", (PyCFunction) _wrap_new_wxGridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellDateTimeRenderer", (PyCFunction) _wrap_new_wxGridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS },
@@ -14359,7 +14174,7 @@ static PyMethodDef gridcMethods[] = {
          { "new_wxGridCellNumberRenderer", (PyCFunction) _wrap_new_wxGridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellStringRenderer", (PyCFunction) _wrap_new_wxGridCellStringRenderer, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellNumberRenderer", (PyCFunction) _wrap_new_wxGridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS },
          { "new_wxGridCellStringRenderer", (PyCFunction) _wrap_new_wxGridCellStringRenderer, METH_VARARGS | METH_KEYWORDS },
          { "wxPyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
-        { "wxPyGridCellRenderer__setSelf", (PyCFunction) _wrap_wxPyGridCellRenderer__setSelf, METH_VARARGS | METH_KEYWORDS },
+        { "wxPyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridCellRenderer", (PyCFunction) _wrap_new_wxPyGridCellRenderer, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_Clone", (PyCFunction) _wrap_wxGridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_GetBestSize", (PyCFunction) _wrap_wxGridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS },
          { "new_wxPyGridCellRenderer", (PyCFunction) _wrap_new_wxPyGridCellRenderer, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_Clone", (PyCFunction) _wrap_wxGridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_GetBestSize", (PyCFunction) _wrap_wxGridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS },
@@ -14367,6 +14182,7 @@ static PyMethodDef gridcMethods[] = {
          { "wxGridCellRenderer_DecRef", (PyCFunction) _wrap_wxGridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_IncRef", (PyCFunction) _wrap_wxGridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_SetParameters", (PyCFunction) _wrap_wxGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_DecRef", (PyCFunction) _wrap_wxGridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_IncRef", (PyCFunction) _wrap_wxGridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS },
          { "wxGridCellRenderer_SetParameters", (PyCFunction) _wrap_wxGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS },
+        { "wxGridCellRenderer__setOORInfo", (PyCFunction) _wrap_wxGridCellRenderer__setOORInfo, METH_VARARGS | METH_KEYWORDS },
          { NULL, NULL }
  };
  #ifdef __cplusplus
          { NULL, NULL }
  };
  #ifdef __cplusplus
@@ -14559,6 +14375,8 @@ SWIGEXPORT(void) initgridc() {
          PyDict_SetItemString(d,"wxGRID_VALUE_CHOICE", PyString_FromString("choice"));
          PyDict_SetItemString(d,"wxGRID_VALUE_TEXT", PyString_FromString("string"));
          PyDict_SetItemString(d,"wxGRID_VALUE_LONG", PyString_FromString("long"));
          PyDict_SetItemString(d,"wxGRID_VALUE_CHOICE", PyString_FromString("choice"));
          PyDict_SetItemString(d,"wxGRID_VALUE_TEXT", PyString_FromString("string"));
          PyDict_SetItemString(d,"wxGRID_VALUE_LONG", PyString_FromString("long"));
+        PyDict_SetItemString(d,"wxGRID_VALUE_CHOICEINT", PyString_FromString("choiceint"));
+        PyDict_SetItemString(d,"wxGRID_VALUE_DATETIME", PyString_FromString("datetime"));
          PyDict_SetItemString(d,"cvar", SWIG_globals);
          SWIG_addvarlink(SWIG_globals,"wxGridNoCellCoords",_wrap_wxGridNoCellCoords_get, _wrap_wxGridNoCellCoords_set);
          SWIG_addvarlink(SWIG_globals,"wxGridNoCellRect",_wrap_wxGridNoCellRect_get, _wrap_wxGridNoCellRect_set);
          PyDict_SetItemString(d,"cvar", SWIG_globals);
          SWIG_addvarlink(SWIG_globals,"wxGridNoCellCoords",_wrap_wxGridNoCellCoords_get, _wrap_wxGridNoCellCoords_set);
          SWIG_addvarlink(SWIG_globals,"wxGridNoCellRect",_wrap_wxGridNoCellRect_get, _wrap_wxGridNoCellRect_set);