compilation fix for recent commit

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

index 5e0971123d82239465512a21ee0f8140aa07f9da..b227d03dbba7ab8511d6d309c29d6f9af4fa53d2 100644 (file)
--- a/wxPython/src/grid.i
+++ b/wxPython/src/grid.i
@@ -15,8 +15,9 @@
  #ifndef OLD_GRID
  
  %{
  #ifndef OLD_GRID
  
  %{
-#include "helpers.h"
+#include "export.h"
  #include <wx/grid.h>
  #include <wx/grid.h>
+#include <wx/generic/gridctrl.h>
  %}
  
  //----------------------------------------------------------------------
  %}
  
  //----------------------------------------------------------------------
@@ -43,381 +44,402 @@
  
  
  %{
  
  
  %{
-#define PYCALLBACK_GCA_INTINT(PCLASS, CBNAME)                           \
-    wxGridCellAttr* CBNAME(int a, int b) {                              \
-        wxGridCellAttr* rval = NULL;                                    \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* ro;                                               \
-            wxGridCellAttr* ptr;                                        \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)", a, b)); \
-            if (ro) {                                                   \
+#define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME)                               \
+    wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) {        \
+        wxGridCellAttr* rval = NULL;                                            \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            wxGridCellAttr* ptr;                                                \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
+            if (ro) {                                                           \
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellAttr_p"))    \
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellAttr_p"))    \
-                    rval = ptr;                                         \
-                Py_DECREF(ro);                                          \
-            }                                                           \
-        }                                                               \
-        else                                                            \
-            rval = PCLASS::CBNAME(a, b);                                \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    wxGridCellAttr *base_##CBNAME(int a, int b) {                       \
-        return PCLASS::CBNAME(a, b);                                    \
+                    rval = ptr;                                                 \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a, b, c);                                     \
+        return rval;                                                            \
+    }                                                                           \
+    wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
+        return PCLASS::CBNAME(a, b, c);                                         \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                           \
-    void CBNAME(wxGridCellAttr *attr, int a, int b) {                   \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr");\
-            m_myInst.callCallback(Py_BuildValue("(Oii)", obj, a, b));   \
-            Py_DECREF(obj);                                             \
-        }                                                               \
-        else                                                            \
-            PCLASS::CBNAME(attr, a, b);                                 \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME(wxGridCellAttr *attr, int a, int b) {            \
-        PCLASS::CBNAME(attr, a, b);                                     \
+#define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                                   \
+    void CBNAME(wxGridCellAttr *attr, int a, int b) {                           \
+        wxPyBeginBlockThreads();                            \
+        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));   \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(attr, a, b);                                         \
+    }                                                                           \
+    void base_##CBNAME(wxGridCellAttr *attr, int a, int b) {                    \
+        PCLASS::CBNAME(attr, a, b);                                             \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK__GCAINT(PCLASS, CBNAME)                              \
-    void CBNAME(wxGridCellAttr *attr, int val) {                        \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr");\
-            m_myInst.callCallback(Py_BuildValue("(Oi)", obj, val));     \
-            Py_DECREF(obj);                                             \
-        }                                                               \
-        else                                                            \
-            PCLASS::CBNAME(attr, val);                                  \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME(wxGridCellAttr *attr, int val) {                 \
-        PCLASS::CBNAME(attr, val);                                      \
+#define PYCALLBACK__GCAINT(PCLASS, CBNAME)                                      \
+    void CBNAME(wxGridCellAttr *attr, int val) {                                \
+        wxPyBeginBlockThreads();                            \
+        bool found;                                                             \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val));    \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(attr, val);                                          \
+    }                                                                           \
+    void base_##CBNAME(wxGridCellAttr *attr, int val) {                         \
+        PCLASS::CBNAME(attr, val);                                              \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_INT__pure(CBNAME)                                    \
-    int  CBNAME() {                                                     \
-        bool doSave = wxPyRestoreThread();                              \
-        int rval = 0;                                                   \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("()"));          \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
+#define PYCALLBACK_INT__pure(CBNAME)                                            \
+    int  CBNAME() {                                                             \
+        wxPyBeginBlockThreads();                            \
+        int rval = 0;                                                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
+        wxPyEndBlockThreads();                                             \
+        return rval;                                                            \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_BOOL_INTINT_pure(CBNAME)                             \
-    bool CBNAME(int a, int b) {                                         \
-        bool doSave = wxPyRestoreThread();                              \
-        bool rval = 0;                                                  \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)",a,b));    \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
+#define PYCALLBACK_BOOL_INTINT_pure(CBNAME)                                     \
+    bool CBNAME(int a, int b) {                                                 \
+        wxPyBeginBlockThreads();                            \
+        bool rval = 0;                                                          \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));   \
+        wxPyEndBlockThreads();                                             \
+        return rval;                                                            \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_STRING_INTINT_pure(CBNAME)                           \
-    wxString CBNAME(int a, int b) {                                     \
-        bool doSave = wxPyRestoreThread();                              \
-        wxString rval;                                                  \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",a,b));   \
-            if (ro) {                                                   \
-                PyObject* str = PyObject_Str(ro);                       \
-                rval = PyString_AsString(str);                          \
-                Py_DECREF(ro);  Py_DECREF(str);                         \
-            }                                                           \
-        }                                                               \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
+#define PYCALLBACK_STRING_INTINT_pure(CBNAME)                                   \
+    wxString CBNAME(int a, int b) {                                             \
+        wxPyBeginBlockThreads();                            \
+        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);                                 \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        return rval;                                                            \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK__INTINTSTRING_pure(CBNAME)                           \
-    void CBNAME(int a, int b, const wxString& c) {                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iis)",a,b,c.c_str()));    \
-        wxPySaveThread(doSave);                                         \
+#define PYCALLBACK__INTINTSTRING_pure(CBNAME)                                   \
+    void CBNAME(int a, int b, const wxString& c) {                              \
+        wxPyBeginBlockThreads();                            \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
+        wxPyEndBlockThreads();                                             \
      }
  
  
      }
  
  
-#define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME)                        \
-    wxString CBNAME(int a, int b) {                                     \
-        bool doSave = wxPyRestoreThread();                              \
-        wxString rval;                                                  \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",a,b));   \
-            if (ro) {                                                   \
-                PyObject* str = PyObject_Str(ro);                       \
-                rval = PyString_AsString(str);                          \
-                Py_DECREF(ro);  Py_DECREF(str);                         \
-            }                                                           \
-        } else                                                          \
-            rval = PCLASS::CBNAME(a, b);                                \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    wxString base_##CBNAME(int a, int b) {                              \
-        return PCLASS::CBNAME(a, b);                                    \
+#define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME)                                \
+    wxString CBNAME(int a, int b) {                                             \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        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);                                 \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a, b);                                        \
+        return rval;                                                            \
+    }                                                                           \
+    wxString base_##CBNAME(int a, int b) {                                      \
+        return PCLASS::CBNAME(a, b);                                            \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME)                    \
-    bool CBNAME(int a, int b, const wxString& c)  {                     \
-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(iis)", a,b,c.c_str()));   \
-        else                                                            \
-            rval = PCLASS::CBNAME(a,b,c);                               \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    bool base_##CBNAME(int a, int b, const wxString& c) {               \
-        return PCLASS::CBNAME(a,b,c);                                   \
+#define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME)                            \
+    bool CBNAME(int a, int b, const wxString& c)  {                             \
+        bool rval = 0;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)", a,b,c.c_str()));\
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a,b,c);                                       \
+        return rval;                                                            \
+    }                                                                           \
+    bool base_##CBNAME(int a, int b, const wxString& c) {                       \
+        return PCLASS::CBNAME(a,b,c);                                           \
      }
  
  
  
  
      }
  
  
  
  
-#define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME)                          \
-    long CBNAME(int a, int b)  {                                        \
-        long rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)", a,b));   \
-        else                                                            \
-            rval = PCLASS::CBNAME(a,b);                                 \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    long base_##CBNAME(int a, int b) {                                  \
-        return PCLASS::CBNAME(a,b);                                     \
+#define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME)                                  \
+    long CBNAME(int a, int b)  {                                                \
+        long rval;                                                              \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a,b);                                         \
+        return rval;                                                            \
+    }                                                                           \
+    long base_##CBNAME(int a, int b) {                                          \
+        return PCLASS::CBNAME(a,b);                                             \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                          \
-    bool CBNAME(int a, int b)  {                                        \
-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)", a,b));   \
-        else                                                            \
-            rval = PCLASS::CBNAME(a,b);                                 \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    bool base_##CBNAME(int a, int b) {                                  \
-        return PCLASS::CBNAME(a,b);                                     \
+#define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                                  \
+    bool CBNAME(int a, int b)  {                                                \
+        bool rval = 0;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a,b);                                         \
+        return rval;                                                            \
+    }                                                                           \
+    bool base_##CBNAME(int a, int b) {                                          \
+        return PCLASS::CBNAME(a,b);                                             \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME)                        \
-    double CBNAME(int a, int b) {                                       \
-        bool doSave = wxPyRestoreThread();                              \
-        double rval;                                                    \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",a,b));   \
-            if (ro) {                                                   \
-                PyObject* str = PyObject_Str(ro);                       \
-                rval = PyFloat_AsDouble(str);                           \
-                Py_DECREF(ro);   Py_DECREF(str);                        \
-            }                                                           \
-        } else                                                          \
-            rval = PCLASS::CBNAME(a, b);                                \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    double base_##CBNAME(int a, int b) {                                \
-        return PCLASS::CBNAME(a, b);                                    \
+#define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME)                                \
+    double CBNAME(int a, int b) {                                               \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        double 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 = PyFloat_AsDouble(str);                                   \
+                Py_DECREF(ro);   Py_DECREF(str);                                \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a, b);                                        \
+        return rval;                                                            \
+    }                                                                           \
+    double base_##CBNAME(int a, int b) {                                        \
+        return PCLASS::CBNAME(a, b);                                            \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK__(PCLASS, CBNAME)                                    \
-    void CBNAME()  {                                                    \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("()"));                 \
-        else                                                            \
-            PCLASS::CBNAME();                                           \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME() {                                              \
-        PCLASS::CBNAME();                                               \
+#define PYCALLBACK__(PCLASS, CBNAME)                                            \
+    void CBNAME()  {                                                            \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME();                                                   \
+    }                                                                           \
+    void base_##CBNAME() {                                                      \
+        PCLASS::CBNAME();                                                       \
      }
  
  
  
  
      }
  
  
  
  
-#define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME)                      \
-    bool CBNAME(size_t a, size_t b)  {                                  \
-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)", a,b));   \
-        else                                                            \
-            rval = PCLASS::CBNAME(a,b);                                 \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    bool base_##CBNAME(size_t a, size_t b) {                            \
-        return PCLASS::CBNAME(a,b);                                     \
+#define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME)                              \
+    bool CBNAME(size_t a, size_t b)  {                                          \
+        bool rval = 0;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a,b);                                         \
+        return rval;                                                            \
+    }                                                                           \
+    bool base_##CBNAME(size_t a, size_t b) {                                    \
+        return PCLASS::CBNAME(a,b);                                             \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME)                           \
-    bool CBNAME(size_t a)  {                                            \
-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(i)", a));      \
-        else                                                            \
-            rval = PCLASS::CBNAME(a);                                   \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    bool base_##CBNAME(size_t a) {                                      \
-        return PCLASS::CBNAME(a);                                       \
+#define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME)                                   \
+    bool CBNAME(size_t a)  {                                                    \
+        bool rval = 0;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }                                                                           \
+    bool base_##CBNAME(size_t a) {                                              \
+        return PCLASS::CBNAME(a);                                               \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK_STRING_INT(PCLASS, CBNAME)                           \
-    wxString CBNAME(int a) {                                            \
-        bool doSave = wxPyRestoreThread();                              \
-        wxString rval;                                                  \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* ro;                                               \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(i)",a));      \
-            if (ro) {                                                   \
-                PyObject* str = PyObject_Str(ro);                       \
-                rval = PyString_AsString(str);                          \
-                Py_DECREF(ro);   Py_DECREF(str);                        \
-            }                                                           \
-        } else                                                          \
-            rval = PCLASS::CBNAME(a);                                   \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    wxString base_##CBNAME(int a) {                                     \
-        return PCLASS::CBNAME(a);                                       \
+#define PYCALLBACK_STRING_INT(PCLASS, CBNAME)                                   \
+    wxString CBNAME(int a) {                                                    \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        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);                                \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }                                                                           \
+    wxString base_##CBNAME(int a) {                                             \
+        return PCLASS::CBNAME(a);                                               \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                           \
-    void CBNAME(int a, const wxString& c)  {                            \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(is)", a,c.c_str()));  \
-        else                                                            \
-            PCLASS::CBNAME(a,c);                                        \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME(int a, const wxString& c) {                      \
-        PCLASS::CBNAME(a,c);                                            \
+#define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                                   \
+    void CBNAME(int a, const wxString& c)  {                                    \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(is)", a,c.c_str())); \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,c);                                                \
+    }                                                                           \
+    void base_##CBNAME(int a, const wxString& c) {                              \
+        PCLASS::CBNAME(a,c);                                                    \
      }
  
  
  
  
      }
  
  
  
  
-#define PYCALLBACK_BOOL_(PCLASS, CBNAME)                                \
-    bool CBNAME()  {                                                    \
-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("()"));          \
-        else                                                            \
-            rval = PCLASS::CBNAME();                                    \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    bool base_##CBNAME() {                                              \
-        return PCLASS::CBNAME();                                        \
+#define PYCALLBACK_BOOL_(PCLASS, CBNAME)                                        \
+    bool CBNAME()  {                                                            \
+        bool rval = 0;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME();                                            \
+        return rval;                                                            \
+    }                                                                           \
+    bool base_##CBNAME() {                                                      \
+        return PCLASS::CBNAME();                                                \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                            \
-    void CBNAME(size_t a, int b)  {                                     \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(ii)", a,b));          \
-        else                                                            \
-            PCLASS::CBNAME(a,b);                                        \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME(size_t a, int b) {                               \
-        PCLASS::CBNAME(a,b);                                            \
+#define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                                    \
+    void CBNAME(size_t a, int b)  {                                             \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));         \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,b);                                                \
+    }                                                                           \
+    void base_##CBNAME(size_t a, int b) {                                       \
+        PCLASS::CBNAME(a,b);                                                    \
      }
  
  
  
  
      }
  
  
  
  
-#define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                          \
-    void CBNAME(int a, int b, long c)  {                                \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iii)", a,b,c));       \
-        else                                                            \
-            PCLASS::CBNAME(a,b,c);                                      \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME(int a, int b, long c) {                          \
-        PCLASS::CBNAME(a,b,c);                                          \
+#define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                                  \
+    void CBNAME(int a, int b, long c)  {                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,b,c);                                              \
+    }                                                                           \
+    void base_##CBNAME(int a, int b, long c) {                                  \
+        PCLASS::CBNAME(a,b,c);                                                  \
      }
  
  
  
  
      }
  
  
  
  
-#define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                        \
-    void CBNAME(int a, int b, double c)  {                              \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iif)", a,b,c));       \
-        else                                                            \
-            PCLASS::CBNAME(a,b,c);                                      \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME(int a, int b, double c) {                        \
-        PCLASS::CBNAME(a,b,c);                                          \
+#define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                                \
+    void CBNAME(int a, int b, double c)  {                                      \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c));      \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,b,c);                                              \
+    }                                                                           \
+    void base_##CBNAME(int a, int b, double c) {                                \
+        PCLASS::CBNAME(a,b,c);                                                  \
      }
  
  
  
      }
  
  
  
-#define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                          \
-    void CBNAME(int a, int b, bool c)  {                                \
-        bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(iii)", a,b,c));       \
-        else                                                            \
-            PCLASS::CBNAME(a,b,c);                                      \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void base_##CBNAME(int a, int b, bool c) {                          \
-        PCLASS::CBNAME(a,b,c);                                          \
+#define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                                  \
+    void CBNAME(int a, int b, bool c)  {                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,b,c);                                              \
+    }                                                                           \
+    void base_##CBNAME(int a, int b, bool c) {                                  \
+        PCLASS::CBNAME(a,b,c);                                                  \
      }
  
  
      }
  
  
@@ -483,31 +505,31 @@ 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) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Draw")) {
-            m_myInst.callCallback(
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "Draw")) {
+            wxPyCBH_callCallback(m_myInst,
                  Py_BuildValue("(OOOOiii)",
                  Py_BuildValue("(OOOOiii)",
-                              wxPyConstructObject((void*)&grid, "wxGrid"),
-                              wxPyConstructObject((void*)&attr, "wxGridCellAttr"),
-                              wxPyConstructObject((void*)&dc,   "wxDC"),
-                              wxPyConstructObject((void*)&rect, "wxRect"),
+                              wxPyConstructObject((void*)&grid, "wxGrid", 0),
+                              wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
+                              wxPyConstructObject((void*)&dc,   "wxDC", 0),
+                              wxPyConstructObject((void*)&rect, "wxRect", 0),
                                row, col, isSelected));
          }
                                row, col, isSelected));
          }
-        wxPySaveThread(doSave);
+        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;
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("GetBestSize")) {
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
              PyObject* ro;
              wxSize*   ptr;
              PyObject* ro;
              wxSize*   ptr;
-            ro = m_myInst.callCallbackObj(
+            ro = wxPyCBH_callCallbackObj(m_myInst,
                  Py_BuildValue("(OOOii)",
                  Py_BuildValue("(OOOii)",
-                              wxPyConstructObject((void*)&grid, "wxGrid"),
-                              wxPyConstructObject((void*)&attr, "wxGridCellAttr"),
-                              wxPyConstructObject((void*)&dc,   "wxDC"),
+                              wxPyConstructObject((void*)&grid, "wxGrid", 0),
+                              wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
+                              wxPyConstructObject((void*)&dc,   "wxDC", 0),
                                row, col));
              if (ro) {
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))
                                row, col));
              if (ro) {
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))
@@ -515,25 +537,25 @@ public:
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
          return rval;
      }
  
  
      wxGridCellRenderer *Clone() const {
          wxGridCellRenderer* rval = NULL;
          return rval;
      }
  
  
      wxGridCellRenderer *Clone() const {
          wxGridCellRenderer* rval = NULL;
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Clone")) {
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "Clone")) {
              PyObject* ro;
              wxGridCellRenderer* ptr;
              PyObject* ro;
              wxGridCellRenderer* ptr;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
              if (ro) {
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellRenderer_p"))
                      rval = ptr;
                  Py_DECREF(ro);
              }
          }
              if (ro) {
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellRenderer_p"))
                      rval = ptr;
                  Py_DECREF(ro);
              }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
          return rval;
      }
  
          return rval;
      }
  
@@ -551,8 +573,8 @@ IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters)
  class wxPyGridCellRenderer : public wxGridCellRenderer {
  public:
      wxPyGridCellRenderer();
  class wxPyGridCellRenderer : public wxGridCellRenderer {
  public:
      wxPyGridCellRenderer();
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridCellRenderer)"
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyGridCellRenderer)"
  
      void base_SetParameters(const wxString& params);
  };
  
      void base_SetParameters(const wxString& params);
  };
@@ -593,6 +615,27 @@ public:
  };
  
  
  };
  
  
+class wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
+{
+public:
+    wxGridCellDateTimeRenderer(wxString outformat = "%c",
+                               wxString informat =  "%c");
+};
+
+
+class wxGridCellEnumRenderer : public wxGridCellStringRenderer
+{
+public:
+    wxGridCellEnumRenderer( const wxString& choices = "" );
+};
+
+
+class wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
+{
+public:
+    wxGridCellAutoWrapStringRenderer();
+};
+
  
  //---------------------------------------------------------------------------
  // wxGridCellEditor is an ABC, and several derived classes are available.
  
  //---------------------------------------------------------------------------
  // wxGridCellEditor is an ABC, and several derived classes are available.
@@ -637,69 +680,70 @@ public:
      wxPyGridCellEditor() : wxGridCellEditor() {}
  
      void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
      wxPyGridCellEditor() : wxGridCellEditor() {}
  
      void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Create")) {
-            m_myInst.callCallback(
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "Create")) {
+            wxPyCBH_callCallback(m_myInst,
                  Py_BuildValue("(OiO)",
                  Py_BuildValue("(OiO)",
-                              wxPyConstructObject((void*)parent, "wxWindow"),
+                              wxPyConstructObject((void*)parent, "wxWindow", 0),
                                id,
                                id,
-                              wxPyConstructObject((void*)evtHandler, "wxEvtHandler")));
+                              wxPyConstructObject((void*)evtHandler, "wxEvtHandler", 0)));
          }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
      }
  
  
      void BeginEdit(int row, int col, wxGrid* grid) {
      }
  
  
      void BeginEdit(int row, int col, wxGrid* grid) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("BeginEdit")) {
-            m_myInst.callCallback(
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
+            wxPyCBH_callCallback(m_myInst,
                  Py_BuildValue("(iiO)", row, col,
                  Py_BuildValue("(iiO)", row, col,
-                              wxPyConstructObject((void*)grid, "wxGrid")));
+                              wxPyConstructObject((void*)grid, "wxGrid", 0)));
          }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
      }
  
  
      bool EndEdit(int row, int col, wxGrid* grid) {
          bool rv = FALSE;
      }
  
  
      bool EndEdit(int row, int col, wxGrid* grid) {
          bool rv = FALSE;
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("EndEdit")) {
-            rv = m_myInst.callCallback(
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
+            rv = wxPyCBH_callCallback(m_myInst,
                  Py_BuildValue("(iiO)", row, col,
                  Py_BuildValue("(iiO)", row, col,
-                              wxPyConstructObject((void*)grid, "wxGrid")));
+                              wxPyConstructObject((void*)grid, "wxGrid", 0)));
          }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
          return rv;
      }
  
  
      wxGridCellEditor*Clone() const {
          wxGridCellEditor* rval = NULL;
          return rv;
      }
  
  
      wxGridCellEditor*Clone() const {
          wxGridCellEditor* rval = NULL;
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Clone")) {
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "Clone")) {
              PyObject* ro;
              wxGridCellEditor* ptr;
              PyObject* ro;
              wxGridCellEditor* ptr;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("()"));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
              if (ro) {
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellEditor_p"))
                      rval = ptr;
                  Py_DECREF(ro);
              }
          }
              if (ro) {
                  if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellEditor_p"))
                      rval = ptr;
                  Py_DECREF(ro);
              }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
          return rval;
      }
  
  
      void Show(bool show, wxGridCellAttr *attr) {
          return rval;
      }
  
  
      void Show(bool show, wxGridCellAttr *attr) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("Show"))
-            m_myInst.callCallback(
+        bool found;
+        wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "Show")))
+            wxPyCBH_callCallback(m_myInst,
                  Py_BuildValue("(iO)", show,
                  Py_BuildValue("(iO)", show,
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr")));
-        else
+                              wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
+        wxPyEndBlockThreads();
+        if (! found)
              wxGridCellEditor::Show(show, attr);
              wxGridCellEditor::Show(show, attr);
-        wxPySaveThread(doSave);
      }
      void base_Show(bool show, wxGridCellAttr *attr) {
          wxGridCellEditor::Show(show, attr);
      }
      void base_Show(bool show, wxGridCellAttr *attr) {
          wxGridCellEditor::Show(show, attr);
@@ -707,15 +751,16 @@ public:
  
  
      void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
  
  
      void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("PaintBackground"))
-            m_myInst.callCallback(
+        bool found;                                                             \
+        wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)")))
+            wxPyCBH_callCallback(m_myInst,
                  Py_BuildValue("(OO)",
                  Py_BuildValue("(OO)",
-                              wxPyConstructObject((void*)&rectCell, "wxRect"),
-                              wxPyConstructObject((void*)attr, "wxGridCellAttr")));
-        else
+                              wxPyConstructObject((void*)&rectCell, "wxRect", 0),
+                              wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
+        wxPyEndBlockThreads();
+        if (! found)
              wxGridCellEditor::PaintBackground(rectCell, attr);
              wxGridCellEditor::PaintBackground(rectCell, attr);
-        wxPySaveThread(doSave);
      }
      void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
          wxGridCellEditor::PaintBackground(rectCell, attr);
      }
      void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
          wxGridCellEditor::PaintBackground(rectCell, attr);
@@ -751,8 +796,8 @@ IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
  class wxPyGridCellEditor : public wxGridCellEditor {
  public:
      wxPyGridCellEditor();
  class wxPyGridCellEditor : public wxGridCellEditor {
  public:
      wxPyGridCellEditor();
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridCellEditor)"
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyGridCellEditor)"
  
      void base_SetSize(const wxRect& rect);
      void base_Show(bool show, wxGridCellAttr *attr = NULL);
  
      void base_SetSize(const wxRect& rect);
      void base_Show(bool show, wxGridCellAttr *attr = NULL);
@@ -803,15 +848,42 @@ public:
                             bool allowOthers = FALSE);
  };
  
                             bool allowOthers = FALSE);
  };
  
+
+class wxGridCellEnumEditor : public wxGridCellChoiceEditor
+{
+public:
+    wxGridCellEnumEditor( const wxString& choices = "" );
+};
+
+
+class wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
+{
+public:
+    wxGridCellAutoWrapStringEditor();
+};
+
+
+
  //---------------------------------------------------------------------------
  
  
  class wxGridCellAttr
  {
  public:
  //---------------------------------------------------------------------------
  
  
  class wxGridCellAttr
  {
  public:
+    enum wxAttrKind
+    {
+        Any,
+        Default,
+        Cell,
+        Row,
+        Col,
+        Merged
+    };
+
      wxGridCellAttr();
  
      wxGridCellAttr *Clone() const;
      wxGridCellAttr();
  
      wxGridCellAttr *Clone() const;
+    void MergeWith(wxGridCellAttr *mergefrom);
      void IncRef();
      void DecRef();
      void SetTextColour(const wxColour& colText);
      void IncRef();
      void DecRef();
      void SetTextColour(const wxColour& colText);
@@ -822,6 +894,7 @@ public:
  
      void SetRenderer(wxGridCellRenderer *renderer);
      void SetEditor(wxGridCellEditor* editor);
  
      void SetRenderer(wxGridCellRenderer *renderer);
      void SetEditor(wxGridCellEditor* editor);
+    void SetKind(wxAttrKind kind);
  
      bool HasTextColour() const;
      bool HasBackgroundColour() const;
  
      bool HasTextColour() const;
      bool HasBackgroundColour() const;
@@ -829,10 +902,11 @@ public:
      bool HasAlignment() const;
      bool HasRenderer() const;
      bool HasEditor() const;
      bool HasAlignment() const;
      bool HasRenderer() const;
      bool HasEditor() const;
+    bool HasReadWriteMode() const;
  
  
-    const wxColour& GetTextColour() const;
-    const wxColour& GetBackgroundColour() const;
-    const wxFont& GetFont() const;
+    wxColour GetTextColour() const;
+    wxColour GetBackgroundColour() const;
+    wxFont GetFont() const;
      void GetAlignment(int *OUTPUT, int *OUTPUT) const;
      wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
      wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
      void GetAlignment(int *OUTPUT, int *OUTPUT) const;
      wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
      wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
@@ -849,7 +923,8 @@ public:
      wxGridCellAttrProvider();
      // ???? virtual ~wxGridCellAttrProvider();
  
      wxGridCellAttrProvider();
      // ???? virtual ~wxGridCellAttrProvider();
  
-    wxGridCellAttr *GetAttr(int row, int col) const;
+    wxGridCellAttr *GetAttr(int row, int col,
+                            wxGridCellAttr::wxAttrKind  kind) const;
      void SetAttr(wxGridCellAttr *attr, int row, int col);
      void SetRowAttr(wxGridCellAttr *attr, int row);
      void SetColAttr(wxGridCellAttr *attr, int col);
      void SetAttr(wxGridCellAttr *attr, int row, int col);
      void SetRowAttr(wxGridCellAttr *attr, int row);
      void SetColAttr(wxGridCellAttr *attr, int col);
@@ -867,7 +942,7 @@ class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
  public:
      wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
  
  public:
      wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
  
-    PYCALLBACK_GCA_INTINT(wxGridCellAttrProvider, GetAttr);
+    PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
      PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
      PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
      PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
      PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
      PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
      PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
@@ -882,10 +957,11 @@ class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
  {
  public:
      wxPyGridCellAttrProvider();
  {
  public:
      wxPyGridCellAttrProvider();
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridCellAttrProvider)"
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyGridCellAttrProvider)"
  
  
-    wxGridCellAttr *base_GetAttr(int row, int col);
+    wxGridCellAttr *base_GetAttr(int row, int col,
+                                 wxGridCellAttr::wxAttrKind kind);
      void base_SetAttr(wxGridCellAttr *attr, int row, int col);
      void base_SetRowAttr(wxGridCellAttr *attr, int row);
      void base_SetColAttr(wxGridCellAttr *attr, int col);
      void base_SetAttr(wxGridCellAttr *attr, int row, int col);
      void base_SetRowAttr(wxGridCellAttr *attr, int row);
      void base_SetColAttr(wxGridCellAttr *attr, int col);
@@ -897,7 +973,7 @@ public:
  
  
  
  
  
  
-class wxGridTableBase
+class wxGridTableBase : public wxObject
  {
  public:
      // wxGridTableBase();   This is an ABC
  {
  public:
      // wxGridTableBase();   This is an ABC
@@ -946,7 +1022,8 @@ public:
  
      virtual bool CanHaveAttributes();
  
  
      virtual bool CanHaveAttributes();
  
-    virtual wxGridCellAttr *GetAttr( int row, int col );
+    virtual wxGridCellAttr *GetAttr( int row, int col,
+                                     wxGridCellAttr::wxAttrKind  kind);
      virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
      virtual void SetRowAttr(wxGridCellAttr *attr, int row);
      virtual void SetColAttr(wxGridCellAttr *attr, int col);
      virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
      virtual void SetRowAttr(wxGridCellAttr *attr, int row);
      virtual void SetColAttr(wxGridCellAttr *attr, int col);
@@ -980,18 +1057,18 @@ public:
      PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
      PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
      PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
      PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
      PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
      PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
-    PYCALLBACK_GCA_INTINT(wxGridTableBase, GetAttr);
+    PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
      PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
      PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
      PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
  
  
      wxString GetValue(int row, int col) {
      PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
      PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
      PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
  
  
      wxString GetValue(int row, int col) {
-        bool doSave = wxPyRestoreThread();
+        wxPyBeginBlockThreads();
          wxString rval;
          wxString rval;
-        if (m_myInst.findCallback("GetValue")) {
+        if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              PyObject* ro;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)",row,col));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
              if (ro) {
                  PyObject* str = PyObject_Str(ro);
                  rval = PyString_AsString(str);
              if (ro) {
                  PyObject* str = PyObject_Str(ro);
                  rval = PyString_AsString(str);
@@ -999,15 +1076,15 @@ public:
                  Py_DECREF(str);
              }
          }
                  Py_DECREF(str);
              }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
          return rval;
      }
  
      void SetValue(int row, int col, const wxString& val) {
          return rval;
      }
  
      void SetValue(int row, int col, const wxString& val) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("SetValue"))
-            m_myInst.callCallback(Py_BuildValue("(iis)",row,col,val.c_str()));
-        wxPySaveThread(doSave);
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "SetValue"))
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",row,col,val.c_str()));
+        wxPyEndBlockThreads();
      }
  
  
      }
  
  
@@ -1015,11 +1092,11 @@ 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;
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("GetValue")) {
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              PyObject* num;
              PyObject* ro;
              PyObject* num;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)", row, col));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
              if (ro && PyNumber_Check(ro)) {
                  num = PyNumber_Int(ro);
                  if (num) {
              if (ro && PyNumber_Check(ro)) {
                  num = PyNumber_Int(ro);
                  if (num) {
@@ -1029,17 +1106,17 @@ public:
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPySaveThread(doSave);
+        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;
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("GetValue")) {
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
              PyObject* ro;
              PyObject* num;
              PyObject* ro;
              PyObject* num;
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(ii)", row, col));
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
              if (ro && PyNumber_Check(ro)) {
                  num = PyNumber_Float(ro);
                  if (num) {
              if (ro && PyNumber_Check(ro)) {
                  num = PyNumber_Float(ro);
                  if (num) {
@@ -1049,7 +1126,7 @@ public:
                  Py_DECREF(ro);
              }
          }
                  Py_DECREF(ro);
              }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
          return rval;
      }
  
          return rval;
      }
  
@@ -1058,19 +1135,19 @@ public:
      }
  
      void SetValueAsLong( int row, int col, long value ) {
      }
  
      void SetValueAsLong( int row, int col, long value ) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("SetValue")) {
-            m_myInst.callCallback(Py_BuildValue("(iii)", row, col, value));
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
          }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
      }
  
      void SetValueAsDouble( int row, int col, double value ) {
      }
  
      void SetValueAsDouble( int row, int col, double value ) {
-        bool doSave = wxPyRestoreThread();
-        if (m_myInst.findCallback("SetValue")) {
-            m_myInst.callCallback(Py_BuildValue("(iid)", row, col, value));
+        wxPyBeginBlockThreads();
+        if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
          }
          }
-        wxPySaveThread(doSave);
+        wxPyEndBlockThreads();
      }
  
      void SetValueAsBool( int row, int col, bool value ) {
      }
  
      void SetValueAsBool( int row, int col, bool value ) {
@@ -1088,8 +1165,8 @@ class wxPyGridTableBase : public wxGridTableBase
  {
  public:
      wxPyGridTableBase();
  {
  public:
      wxPyGridTableBase();
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridTableBase)"
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyGridTableBase)"
  
      %addmethods { void Destroy() { delete self; } }
  
  
      %addmethods { void Destroy() { delete self; } }
  
@@ -1108,7 +1185,8 @@ public:
      void base_SetRowLabelValue( int row, const wxString& value );
      void base_SetColLabelValue( int col, const wxString& value );
      bool base_CanHaveAttributes();
      void base_SetRowLabelValue( int row, const wxString& value );
      void base_SetColLabelValue( int col, const wxString& value );
      bool base_CanHaveAttributes();
-    wxGridCellAttr *base_GetAttr( int row, int col );
+    wxGridCellAttr *base_GetAttr( int row, int col,
+                                  wxGridCellAttr::wxAttrKind kind );
      void base_SetAttr(wxGridCellAttr* attr, int row, int col);
      void base_SetRowAttr(wxGridCellAttr *attr, int row);
      void base_SetColAttr(wxGridCellAttr *attr, int col);
      void base_SetAttr(wxGridCellAttr* attr, int row, int col);
      void base_SetRowAttr(wxGridCellAttr *attr, int row);
      void base_SetColAttr(wxGridCellAttr *attr, int col);
@@ -1248,7 +1326,7 @@ public:
              long style = wxWANTS_CHARS,
              const char* name = wxPanelNameStr );
  
              long style = wxWANTS_CHARS,
              const char* name = wxPanelNameStr );
  
-    //~wxGrid();
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
  
      enum wxGridSelectionModes {wxGridSelectCells,
                                 wxGridSelectRows,
  
      enum wxGridSelectionModes {wxGridSelectCells,
                                 wxGridSelectRows,
@@ -1265,24 +1343,6 @@ public:
      int      GetNumberCols();
  
  
      int      GetNumberCols();
  
  
-
-#ifdef NOTNEEDED // ????
-    // ------ display update functions
-    //
-    void CalcRowLabelsExposed( wxRegion& reg );
-    void CalcColLabelsExposed( wxRegion& reg );
-    void CalcCellsExposed( wxRegion& reg );
-
-    // ------ event handlers
-    //
-    void ProcessRowLabelMouseEvent( wxMouseEvent& event );
-    void ProcessColLabelMouseEvent( wxMouseEvent& event );
-    void ProcessCornerLabelMouseEvent( wxMouseEvent& event );
-    void ProcessGridCellMouseEvent( wxMouseEvent& event );
-    void DoEndDragResizeRow();
-    void DoEndDragResizeCol();
-#endif
-
      bool ProcessTableMessage( wxGridTableMessage& );
  
  
      bool ProcessTableMessage( wxGridTableMessage& );
  
  
@@ -1299,26 +1359,11 @@ public:
      bool AppendCols( int numCols = 1, bool updateLabels=TRUE );
      bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels=TRUE );
  
      bool AppendCols( int numCols = 1, bool updateLabels=TRUE );
      bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels=TRUE );
  
-#ifdef NOTNEEDED // ????
-    void DrawGridCellArea( wxDC& dc );
-    void DrawGridSpace( wxDC& dc );
-    void DrawCellBorder( wxDC& dc, const wxGridCellCoords& );
-    void DrawAllGridLines( wxDC& dc, const wxRegion & reg );
-    void DrawCell( wxDC& dc, const wxGridCellCoords& );
-    void DrawHighlight(wxDC& dc);
-#endif
  
      // this function is called when the current cell highlight must be redrawn
      // and may be overridden by the user
      virtual void DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr );
  
  
      // this function is called when the current cell highlight must be redrawn
      // and may be overridden by the user
      virtual void DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr );
  
-#ifdef NOTNEEDED // ????
-    void DrawRowLabels( wxDC& dc );
-    void DrawRowLabel( wxDC& dc, int row );
-
-    void DrawColLabels( wxDC& dc );
-    void DrawColLabel( wxDC& dc, int col );
-#endif
  
      // ------ Cell text drawing functions
      //
  
      // ------ Cell text drawing functions
      //
@@ -1326,10 +1371,10 @@ public:
                              int horizontalAlignment = wxLEFT,
                              int verticalAlignment = wxTOP );
  
                              int horizontalAlignment = wxLEFT,
                              int verticalAlignment = wxTOP );
  
-    // Split a string containing newline chararcters into an array of
-    // strings and return the number of lines
-    //
-    void StringToLines( const wxString& value, wxArrayString& lines );
+//      // Split a string containing newline chararcters into an array of
+//      // strings and return the number of lines
+//      //
+//      void StringToLines( const wxString& value, wxArrayString& lines );
  
      void GetTextBoxSize( wxDC& dc,
                           wxArrayString& lines,
  
      void GetTextBoxSize( wxDC& dc,
                           wxArrayString& lines,
@@ -1344,6 +1389,7 @@ public:
      void     BeginBatch();
      void     EndBatch();
      int      GetBatchCount();
      void     BeginBatch();
      void     EndBatch();
      int      GetBatchCount();
+    void     ForceRefresh();
  
  
      // ------ edit control functions
  
  
      // ------ edit control functions
@@ -1431,6 +1477,8 @@ public:
      wxString GetColLabelValue( int col );
      wxColour GetGridLineColour();
      wxColour GetCellHighlightColour();
      wxString GetColLabelValue( int col );
      wxColour GetGridLineColour();
      wxColour GetCellHighlightColour();
+    int      GetCellHighlightPenWidth();
+    int      GetCellHighlightROPenWidth();
  
      void     SetRowLabelSize( int width );
      void     SetColLabelSize( int height );
  
      void     SetRowLabelSize( int width );
      void     SetColLabelSize( int height );
@@ -1443,6 +1491,8 @@ public:
      void     SetColLabelValue( int col, const wxString& );
      void     SetGridLineColour( const wxColour& );
      void     SetCellHighlightColour( const wxColour& );
      void     SetColLabelValue( int col, const wxString& );
      void     SetGridLineColour( const wxColour& );
      void     SetCellHighlightColour( const wxColour& );
+    void     SetCellHighlightPenWidth(int width);
+    void     SetCellHighlightROPenWidth(int width);
  
      void     EnableDragRowSize( bool enable = TRUE );
      void     DisableDragRowSize();
  
      void     EnableDragRowSize( bool enable = TRUE );
      void     DisableDragRowSize();
@@ -1595,6 +1645,15 @@ public:
      // grid may occupy more space than needed for its rows/columns, this
      // function allows to set how big this extra space is
      void SetMargins(int extraWidth, int extraHeight);
      // grid may occupy more space than needed for its rows/columns, this
      // function allows to set how big this extra space is
      void SetMargins(int extraWidth, int extraHeight);
+
+
+    // Accessors for component windows
+    wxWindow* GetGridWindow();
+    wxWindow* GetGridRowLabelWindow();
+    wxWindow* GetGridColLabelWindow();
+    wxWindow* GetGridCornerLabelWindow();
+
+
  };
  
  
  };
  
  
@@ -1663,6 +1722,22 @@ public:
      bool        AltDown();
  };
  
      bool        AltDown();
  };
  
+
+class wxGridEditorCreatedEvent : public wxCommandEvent {
+public:
+    wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj,
+                             int row, int col, wxControl* ctrl);
+
+    int GetRow();
+    int GetCol();
+    wxControl* GetControl();
+    void SetRow(int row);
+    void SetCol(int col);
+    void SetControl(wxControl* ctrl);
+};
+
+
+
  enum {
      wxEVT_GRID_CELL_LEFT_CLICK,
      wxEVT_GRID_CELL_RIGHT_CLICK,
  enum {
      wxEVT_GRID_CELL_LEFT_CLICK,
      wxEVT_GRID_CELL_RIGHT_CLICK,
@@ -1679,6 +1754,7 @@ enum {
      wxEVT_GRID_SELECT_CELL,
      wxEVT_GRID_EDITOR_SHOWN,
      wxEVT_GRID_EDITOR_HIDDEN,
      wxEVT_GRID_SELECT_CELL,
      wxEVT_GRID_EDITOR_SHOWN,
      wxEVT_GRID_EDITOR_HIDDEN,
+    wxEVT_GRID_EDITOR_CREATED,
  };
  
  
  };
  
  
@@ -1729,10 +1805,20 @@ def EVT_GRID_EDITOR_SHOWN(win, fn):
  def EVT_GRID_EDITOR_HIDDEN(win, fn):
      win.Connect(-1, -1, wxEVT_GRID_EDITOR_HIDDEN, fn)
  
  def EVT_GRID_EDITOR_HIDDEN(win, fn):
      win.Connect(-1, -1, wxEVT_GRID_EDITOR_HIDDEN, fn)
  
+def EVT_GRID_EDITOR_CREATED(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_EDITOR_CREATED, fn)
+
  "
  
  //---------------------------------------------------------------------------
  
  "
  
  //---------------------------------------------------------------------------
  
+%init %{
+    wxClassInfo::CleanUpClasses();
+    wxClassInfo::InitializeClasses();
+%}
+
+//---------------------------------------------------------------------------
+
  %pragma(python) include="_gridextras.py";
  
  //---------------------------------------------------------------------------
  %pragma(python) include="_gridextras.py";
  
  //---------------------------------------------------------------------------