make wxArtProvider pure virtual (I was not so on

[wxWidgets.git] / wxPython / src / helpers.h
diff --git a/wxPython/src/helpers.h b/wxPython/src/helpers.h

index b9c07e3a84b4d4b688560b4aaf82923b772187ae..4ec75ec53432b78799685b2e20cf6c6de778737e 100644 (file)
--- a/wxPython/src/helpers.h
+++ b/wxPython/src/helpers.h
@@ -15,21 +15,6 @@
  
  #include <wx/wx.h>
  
  
  #include <wx/wx.h>
  
-//----------------------------------------------------------------------
-
-// if we want to handle threads and Python threads are available...
-#if defined(WXP_USE_THREAD) && defined(WITH_THREAD)
-
-#define WXP_WITH_THREAD
-#define wxPy_BEGIN_ALLOW_THREADS  Py_BEGIN_ALLOW_THREADS
-#define wxPy_END_ALLOW_THREADS    Py_END_ALLOW_THREADS
-
-#else  // no Python threads...
-#undef WXP_WITH_THREAD
-#define wxPy_BEGIN_ALLOW_THREADS
-#define wxPy_END_ALLOW_THREADS
-#endif
-
  
  //---------------------------------------------------------------------------
  
  
  //---------------------------------------------------------------------------
  
@@ -41,9 +26,10 @@ class wxPyApp: public wxApp
  public:
      wxPyApp();
      ~wxPyApp();
  public:
      wxPyApp();
      ~wxPyApp();
-    int  MainLoop(void);
-    bool OnInit(void);
+    bool OnInit();
+    int  MainLoop();
  };
  };
+
  extern wxPyApp *wxPythonApp;
  
  //----------------------------------------------------------------------
  extern wxPyApp *wxPythonApp;
  
  //----------------------------------------------------------------------
@@ -58,74 +44,47 @@ PyObject* __wxSetDictionary(PyObject*, PyObject* args);
  void wxPyEventThunker(wxObject*, wxEvent& event);
  
  PyObject* wxPyConstructObject(void* ptr,
  void wxPyEventThunker(wxObject*, wxEvent& event);
  
  PyObject* wxPyConstructObject(void* ptr,
-                              const char* className,
+                              const wxString& className,
                                int setThisOwn=0);
  PyObject* wxPyConstructObject(void* ptr,
                                int setThisOwn=0);
  PyObject* wxPyConstructObject(void* ptr,
-                              const char* className,
+                              const wxString& className,
                                PyObject* klass,
                                int setThisOwn=0);
                                PyObject* klass,
                                int setThisOwn=0);
-PyObject*  wxPyClassExists(const char* className);
-PyObject*  wxPyMake_wxObject(wxObject* source);
-void       wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
-
-PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
-long wxPyGetWinHandle(wxWindow* win);
-
-//----------------------------------------------------------------------
-
-struct wxPyTState {
-    PyThreadState* newState;
-    PyThreadState* prevState;
-
-    wxPyTState() : newState(NULL), prevState(NULL) {}
-};
  
  
+PyObject* wx2PyString(const wxString& src);
+wxString  Py2wxString(PyObject* source);
  
  
-wxPyTState* wxPyBeginBlockThreads();
-void        wxPyEndBlockThreads(wxPyTState* state);
+PyObject* wxPyClassExists(const wxString& className);
+PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler=TRUE);
+PyObject* wxPyMake_wxSizer(wxSizer* source);
+void      wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
  
  
+PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
+long      wxPyGetWinHandle(wxWindow* win);
  
  //----------------------------------------------------------------------
  
  //----------------------------------------------------------------------
-// Handle wxInputStreams by Joerg Baumann
-// See stream.i for implementations
  
  
-// list class for return list of strings, e.g. readlines()
-WX_DECLARE_LIST(wxString, wxStringPtrList);
+// if we want to handle threads and Python threads are available...
+#if defined(WXP_USE_THREAD) && defined(WITH_THREAD)
+#define WXP_WITH_THREAD
+#else  // no Python threads...
+#undef WXP_WITH_THREAD
+#endif
  
  
  
  
-// C++ class wxPyInputStream to act as base for python class wxInputStream
-// Use it in python like a python file object
-class wxPyInputStream {
-public:
-    // underlying wxInputStream
-    wxInputStream* wxi;
-
-public:
-    wxPyInputStream(wxInputStream* wxi_) : wxi(wxi_) {}
-    ~wxPyInputStream();
-
-    // python file object interface for input files (most of it)
-    void close();
-    void flush();
-    bool eof();
-    wxString* read(int size=-1);
-    wxString* readline(int size=-1);
-    wxStringPtrList* readlines(int sizehint=-1);
-    void seek(int offset, int whence=0);
-    int tell();
-    /*
-      bool isatty();
-      int fileno();
-      void truncate(int size=-1);
-      void write(wxString data);
-      void writelines(wxStringPtrList);
-    */
-};
+// For Python --> C++
+PyThreadState* wxPyBeginAllowThreads();
+void           wxPyEndAllowThreads(PyThreadState* state);
  
  
+// For C++ --> Python
+void wxPyBeginBlockThreads();
+void wxPyEndBlockThreads();
  
  //----------------------------------------------------------------------
  // These are helpers used by the typemaps
  
  
  //----------------------------------------------------------------------
  // These are helpers used by the typemaps
  
+wxString* wxString_in_helper(PyObject* source);
+
  byte* byte_LIST_helper(PyObject* source);
  int* int_LIST_helper(PyObject* source);
  long* long_LIST_helper(PyObject* source);
  byte* byte_LIST_helper(PyObject* source);
  int* int_LIST_helper(PyObject* source);
  long* long_LIST_helper(PyObject* source);
@@ -134,6 +93,7 @@ wxPoint* wxPoint_LIST_helper(PyObject* source, int* npoints);
  wxBitmap** wxBitmap_LIST_helper(PyObject* source);
  wxString* wxString_LIST_helper(PyObject* source);
  wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
  wxBitmap** wxBitmap_LIST_helper(PyObject* source);
  wxString* wxString_LIST_helper(PyObject* source);
  wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+wxPen** wxPen_LIST_helper(PyObject* source);
  
  bool wxSize_helper(PyObject* source, wxSize** obj);
  bool wxPoint_helper(PyObject* source, wxPoint** obj);
  
  bool wxSize_helper(PyObject* source, wxSize** obj);
  bool wxPoint_helper(PyObject* source, wxPoint** obj);
@@ -141,6 +101,25 @@ bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
  bool wxRect_helper(PyObject* source, wxRect** obj);
  bool wxColour_helper(PyObject* source, wxColour** obj);
  
  bool wxRect_helper(PyObject* source, wxRect** obj);
  bool wxColour_helper(PyObject* source, wxColour** obj);
  
+//----------------------------------------------------------------------
+// Other helpful stuff
+
+#if PYTHON_API_VERSION < 1009
+#define PySequence_Fast_GET_ITEM(o, i) \
+     (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
+#endif
+
+bool _2int_seq_helper(PyObject* source, int* i1, int* i2);
+bool _4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4);
+
+
+PyObject* wxArrayString2PyList_helper(const wxArrayString& arr);
+PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr);
+
+#define RETURN_NONE()                 { Py_INCREF(Py_None); return Py_None; }
+#define DECLARE_DEF_STRING(name)      static const wxString wxPy##name(wx##name)
+#define DECLARE_DEF_STRING2(name,val) static const wxString wxPy##name(val)
+
  //----------------------------------------------------------------------
  
  #ifndef SWIGCODE
  //----------------------------------------------------------------------
  
  #ifndef SWIGCODE
@@ -204,25 +183,39 @@ protected:
  
  
  class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
  
  
  class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
-    DECLARE_DYNAMIC_CLASS(wxPyEvent)
+    DECLARE_ABSTRACT_CLASS(wxPyEvent)
  public:
      wxPyEvent(int id=0);
  public:
      wxPyEvent(int id=0);
+    wxPyEvent(const wxPyEvent& evt);
      ~wxPyEvent();
  
      ~wxPyEvent();
  
-    void CopyObject(wxObject& dest) const;
+    virtual wxEvent* Clone() const { return new wxPyEvent(*this); }
  };
  
  
  class wxPyCommandEvent : public wxCommandEvent, public wxPyEvtSelfRef {
  };
  
  
  class wxPyCommandEvent : public wxCommandEvent, public wxPyEvtSelfRef {
-    DECLARE_DYNAMIC_CLASS(wxPyCommandEvent)
+    DECLARE_ABSTRACT_CLASS(wxPyCommandEvent)
  public:
      wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0);
  public:
      wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0);
+    wxPyCommandEvent(const wxPyCommandEvent& evt);
      ~wxPyCommandEvent();
  
      ~wxPyCommandEvent();
  
-    void CopyObject(wxObject& dest) const;
+    virtual wxEvent* Clone() const { return new wxPyCommandEvent(*this); }
  };
  
  
  };
  
  
+
+//----------------------------------------------------------------------
+// Forward decalre a few things used in the exported API
+class wxPyClientData;
+class wxPyUserData;
+class wxPyOORClientData;
+
+void wxPyClientData_dtor(wxPyClientData* self);
+void wxPyUserData_dtor(wxPyUserData* self);
+void wxPyOORClientData_dtor(wxPyOORClientData* self);
+
+
  //---------------------------------------------------------------------------
  // Export a C API in a struct.  Other modules will be able to load this from
  // the wxc module and will then have safe access to these functions, even if
  //---------------------------------------------------------------------------
  // Export a C API in a struct.  Other modules will be able to load this from
  // the wxc module and will then have safe access to these functions, even if
@@ -239,12 +232,18 @@ struct wxPyCoreAPI {
      void        (*p_SWIG_addvarlink)(PyObject*, char*, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p));
      PyObject*   (*p_SWIG_newvarlink)(void);
  
      void        (*p_SWIG_addvarlink)(PyObject*, char*, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p));
      PyObject*   (*p_SWIG_newvarlink)(void);
  
-    wxPyTState* (*p_wxPyBeginBlockThreads)();
-    void        (*p_wxPyEndBlockThreads)(wxPyTState* state);
+    PyThreadState* (*p_wxPyBeginAllowThreads)();
+    void           (*p_wxPyEndAllowThreads)(PyThreadState* state);
+    void        (*p_wxPyBeginBlockThreads)();
+    void        (*p_wxPyEndBlockThreads)();
  
  
-    PyObject*   (*p_wxPyConstructObject)(void *, const char *, int);
+    PyObject*   (*p_wxPyConstructObject)(void *, const wxString&, int);
      PyObject*   (*p_wxPy_ConvertList)(wxListBase* list, const char* className);
  
      PyObject*   (*p_wxPy_ConvertList)(wxListBase* list, const char* className);
  
+    wxString*   (*p_wxString_in_helper)(PyObject* source);
+    wxString    (*p_Py2wxString)(PyObject* source);
+    PyObject*   (*p_wx2PyString)(const wxString& src);
+
      byte*       (*p_byte_LIST_helper)(PyObject* source);
      int*        (*p_int_LIST_helper)(PyObject* source);
      long*       (*p_long_LIST_helper)(PyObject* source);
      byte*       (*p_byte_LIST_helper)(PyObject* source);
      int*        (*p_int_LIST_helper)(PyObject* source);
      long*       (*p_long_LIST_helper)(PyObject* source);
@@ -266,16 +265,76 @@ struct wxPyCoreAPI {
      PyObject*   (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
      void        (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
  
      PyObject*   (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
      void        (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
  
-    PyObject*   (*p_wxPyClassExists)(const char* className);
-    PyObject*   (*p_wxPyMake_wxObject)(wxObject* source);
+    PyObject*   (*p_wxPyClassExists)(const wxString& className);
+    PyObject*   (*p_wxPyMake_wxObject)(wxObject* source, bool checkEvtHandler);
+    PyObject*   (*p_wxPyMake_wxSizer)(wxSizer* source);
      void        (*p_wxPyPtrTypeMap_Add)(const char* commonName, const char* ptrName);
      void        (*p_wxPyPtrTypeMap_Add)(const char* commonName, const char* ptrName);
+    PyObject*   (*p_wxArrayString2PyList_helper)(const wxArrayString& arr);
+    PyObject*   (*p_wxArrayInt2PyList_helper)(const wxArrayInt& arr);
  
  
+    void        (*p_wxPyClientData_dtor)(wxPyClientData*);
+    void        (*p_wxPyUserData_dtor)(wxPyUserData*);
+    void        (*p_wxPyOORClientData_dtor)(wxPyOORClientData*);
  };
  
  #ifdef wxPyUSE_EXPORT
  };
  
  #ifdef wxPyUSE_EXPORT
-static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;  // Each module needs one, but may not use it.
+static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;  // Each module needs one, but doesn't have to use it.
  #endif
  
  #endif
  
+
+//---------------------------------------------------------------------------
+
+
+class wxPyUserData : public wxObject {
+public:
+    wxPyUserData(PyObject* obj) {
+        m_obj = obj;
+        Py_INCREF(m_obj);
+    }
+
+    ~wxPyUserData() {
+#ifdef wxPyUSE_EXPORT
+        wxPyCoreAPIPtr->p_wxPyUserData_dtor(this);
+#else
+        wxPyUserData_dtor(this);
+#endif
+    }
+    PyObject* m_obj;
+};
+
+
+class wxPyClientData : public wxClientData {
+public:
+    wxPyClientData(PyObject* obj) {
+        m_obj = obj;
+        Py_INCREF(m_obj);
+    }
+
+    ~wxPyClientData() {
+#ifdef wxPyUSE_EXPORT
+        wxPyCoreAPIPtr->p_wxPyClientData_dtor(this);
+#else
+        wxPyClientData_dtor(this);
+#endif
+    }
+    PyObject* m_obj;
+};
+
+
+class wxPyOORClientData : public wxPyClientData {
+public:
+    wxPyOORClientData(PyObject* obj)
+        : wxPyClientData(obj) {}
+
+    ~wxPyOORClientData() {
+#ifdef wxPyUSE_EXPORT
+        wxPyCoreAPIPtr->p_wxPyOORClientData_dtor(this);
+#else
+        wxPyOORClientData_dtor(this);
+#endif
+    }
+};
+
  //---------------------------------------------------------------------------
  // This class holds an instance of a Python Shadow Class object and assists
  // with looking up and invoking Python callback methods from C++ virtual
  //---------------------------------------------------------------------------
  // This class holds an instance of a Python Shadow Class object and assists
  // with looking up and invoking Python callback methods from C++ virtual
@@ -326,53 +385,6 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
  
  
  
  
  
  
-//----------------------------------------------------------------------
-
-class wxPyUserData : public wxObject {
-public:
-    wxPyUserData(PyObject* obj) {
-        m_obj = obj;
-        Py_INCREF(m_obj);
-    }
-
-    ~wxPyUserData() {
-#ifdef wxPyUSE_EXPORT
-        wxPyTState* state = wxPyCoreAPIPtr->p_wxPyBeginBlockThreads();
-        Py_DECREF(m_obj);
-        wxPyCoreAPIPtr->p_wxPyEndBlockThreads(state);
-#else
-        wxPyTState* state = wxPyBeginBlockThreads();
-        Py_DECREF(m_obj);
-        wxPyEndBlockThreads(state);
-#endif
-    }
-    PyObject* m_obj;
-};
-
-
-
-class wxPyClientData : public wxClientData {
-public:
-    wxPyClientData(PyObject* obj) {
-        m_obj = obj;
-        Py_INCREF(m_obj);
-    }
-
-    ~wxPyClientData() {
-#ifdef wxPyUSE_EXPORT
-        wxPyTState* state = wxPyCoreAPIPtr->p_wxPyBeginBlockThreads();
-        Py_DECREF(m_obj);
-        wxPyCoreAPIPtr->p_wxPyEndBlockThreads(state);
-#else
-        wxPyTState* state = wxPyBeginBlockThreads();
-        Py_DECREF(m_obj);
-        wxPyEndBlockThreads(state);
-#endif
-    }
-    PyObject* m_obj;
-};
-
-
  
  //---------------------------------------------------------------------------
  // These macros are used to implement the virtual methods that should
  
  //---------------------------------------------------------------------------
  // These macros are used to implement the virtual methods that should
@@ -396,10 +408,10 @@ public:
  #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)                         \
      void CLASS::CBNAME() {                                              \
          bool found;                                                     \
  #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)                         \
      void CLASS::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();                                           \
      }                                                                   \
@@ -417,10 +429,10 @@ public:
  #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
      bool CLASS::CBNAME(int a, int b) {                                  \
          bool rval=FALSE, found;                                         \
  #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
      bool CLASS::CBNAME(int a, int b) {                                  \
          bool rval=FALSE, 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;                                                    \
@@ -439,10 +451,10 @@ public:
  #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
      void CLASS::CBNAME(int a, int b) {                                  \
          bool found;                                                     \
  #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
      void CLASS::CBNAME(int 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);                                        \
      }                                                                   \
@@ -460,10 +472,10 @@ public:
  #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
      bool CLASS::CBNAME(int a) {                                         \
          bool rval=FALSE, found;                                         \
  #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
      bool CLASS::CBNAME(int a) {                                         \
          bool rval=FALSE, 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;                                                    \
@@ -481,11 +493,11 @@ public:
  #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
      bool CLASS::CBNAME(int a) {                                         \
          bool rval=FALSE;                                                \
  #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
      bool CLASS::CBNAME(int a) {                                         \
          bool rval=FALSE;                                                \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                    \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
          else rval = FALSE;                                              \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
          else rval = FALSE;                                              \
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                     \
          return rval;                                                    \
      }
  
          return rval;                                                    \
      }
  
@@ -500,13 +512,13 @@ public:
  #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)                       \
      void CLASS::CBNAME(wxDC& a) {                                       \
          bool found;                                                     \
  #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)                       \
      void CLASS::CBNAME(wxDC& a) {                                       \
          bool found;                                                     \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                    \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));  \
              Py_DECREF(obj);                                             \
          }                                                               \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));  \
              Py_DECREF(obj);                                             \
          }                                                               \
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                     \
          if (! found)                                                    \
              PCLASS::CBNAME(a);                                          \
      }                                                                   \
          if (! found)                                                    \
              PCLASS::CBNAME(a);                                          \
      }                                                                   \
@@ -526,13 +538,13 @@ public:
  #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
      void CLASS::CBNAME(wxDC& a, bool b) {                               \
          bool found;                                                     \
  #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
      void CLASS::CBNAME(wxDC& a, bool b) {                               \
          bool found;                                                     \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                    \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
              Py_DECREF(obj);                                             \
          }                                                               \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
              Py_DECREF(obj);                                             \
          }                                                               \
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                     \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b);                                       \
      }                                                                   \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b);                                       \
      }                                                                   \
@@ -550,13 +562,13 @@ public:
  #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
      void CLASS::CBNAME(wxDC& a, bool b) {                               \
          bool found;                                                     \
  #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
      void CLASS::CBNAME(wxDC& a, bool b) {                               \
          bool found;                                                     \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                    \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
              Py_DECREF(obj);                                             \
          }                                                               \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
              Py_DECREF(obj);                                             \
          }                                                               \
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                     \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b);                                       \
      }                                                                   \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b);                                       \
      }                                                                   \
@@ -574,10 +586,10 @@ public:
  #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
      void CLASS::CBNAME(double a, double b) {                            \
          bool found;                                                     \
  #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
      void CLASS::CBNAME(double a, double b) {                            \
          bool found;                                                     \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                    \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));  \
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                     \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b);                                       \
      }                                                                   \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b);                                       \
      }                                                                   \
@@ -595,11 +607,11 @@ public:
  #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
      void CLASS::CBNAME(double a, double b, int c, int d) {              \
          bool found;                                                     \
  #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
      void CLASS::CBNAME(double a, double b, int c, int d) {              \
          bool found;                                                     \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                    \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",      \
                                                         a,b,c,d));       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",      \
                                                         a,b,c,d));       \
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                     \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b, c, d);                                 \
      }                                                                   \
          if (! found)                                                    \
              PCLASS::CBNAME(a, b, c, d);                                 \
      }                                                                   \
@@ -617,13 +629,13 @@ public:
  #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
      void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
          bool found;                                                                     \
  #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
      void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
          bool found;                                                                     \
-        wxPyTState* state = wxPyBeginBlockThreads();                                    \
+        wxPyBeginBlockThreads();                                    \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
              PyObject* obj = wxPyMake_wxObject(&a);                                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
              Py_DECREF(obj);                                                             \
          }                                                                               \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
              PyObject* obj = wxPyMake_wxObject(&a);                                      \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
              Py_DECREF(obj);                                                             \
          }                                                                               \
-        wxPyEndBlockThreads(state);                                                     \
+        wxPyEndBlockThreads();                                                     \
          if (! found)                                                                    \
              PCLASS::CBNAME(a, b, c, d, e, f);                                           \
      }                                                                                   \
          if (! found)                                                                    \
              PCLASS::CBNAME(a, b, c, d, e, f);                                           \
      }                                                                                   \
@@ -641,14 +653,14 @@ public:
  #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
      bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
          bool found;                                                                     \
  #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
      bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
          bool found;                                                                     \
-        wxPyTState* state = wxPyBeginBlockThreads();                                    \
+        wxPyBeginBlockThreads();                                    \
          bool rval=FALSE;                                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
              PyObject* obj = wxPyMake_wxObject(&a);                                      \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
              Py_DECREF(obj);                                                             \
          }                                                                               \
          bool rval=FALSE;                                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
              PyObject* obj = wxPyMake_wxObject(&a);                                      \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
              Py_DECREF(obj);                                                             \
          }                                                                               \
-        wxPyEndBlockThreads(state);                                                     \
+        wxPyEndBlockThreads();                                                     \
          if (! found)                                                                    \
              rval = PCLASS::CBNAME(a, b, c, d, e, f);                                    \
          return rval;                                                                    \
          if (! found)                                                                    \
              rval = PCLASS::CBNAME(a, b, c, d, e, f);                                    \
          return rval;                                                                    \
@@ -667,11 +679,11 @@ public:
  #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
      void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
          bool found;                                                             \
  #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
      void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \
                                                  (int)a,b,c,d,e));               \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \
                                                  (int)a,b,c,d,e));               \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e);                                      \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e);                                      \
      }                                                                           \
@@ -689,13 +701,13 @@ public:
  #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
      void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
          bool found;                                                             \
  #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
      void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(&a);                              \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(&a);                              \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e);                                      \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e);                                      \
      }                                                                           \
@@ -713,13 +725,13 @@ public:
  #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                           \
      void CLASS::CBNAME(wxDC& a, bool b) {                                       \
          bool found;                                                             \
  #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                           \
      void CLASS::CBNAME(wxDC& a, bool b) {                                       \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(&a);                              \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b)); \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(&a);                              \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b)); \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b);                                               \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b);                                               \
      }                                                                           \
@@ -738,13 +750,13 @@ public:
      void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
                  int e, int f) {                                                 \
          bool found;                                                             \
      void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
                  int e, int f) {                                                 \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(a);                               \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(a);                               \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e, f);                                   \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e, f);                                   \
      }                                                                           \
@@ -763,13 +775,13 @@ public:
  #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
      void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
          bool found;                                                             \
  #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
      void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(a);                               \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(a);                               \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e);                                      \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d, e);                                      \
      }                                                                           \
@@ -788,10 +800,10 @@ public:
  #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \
      void CLASS::CBNAME(double a, double b, int c) {                             \
          bool found;                                                             \
  #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \
      void CLASS::CBNAME(double a, double b, int c) {                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));      \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));      \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c);                                            \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c);                                            \
      }                                                                           \
@@ -809,10 +821,10 @@ public:
  #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
      void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
          bool found;                                                             \
  #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
      void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d);                                         \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a, b, c, d);                                         \
      }                                                                           \
@@ -827,14 +839,13 @@ public:
      void CBNAME(const wxString& a);                     \
      void base_##CBNAME(const wxString& a);
  
      void CBNAME(const wxString& a);                     \
      void base_##CBNAME(const wxString& a);
  
-
  #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                           \
      void CLASS::CBNAME(const wxString& a)  {                                    \
          bool found;                                                             \
  #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                           \
      void CLASS::CBNAME(const wxString& a)  {                                    \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));    \
-        wxPyEndBlockThreads(state);                                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));    \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(a);                                                  \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a);                                                  \
      }                                                                           \
@@ -848,15 +859,14 @@ public:
      bool CBNAME(const wxString& a);                     \
      bool base_##CBNAME(const wxString& a);
  
      bool CBNAME(const wxString& a);                     \
      bool base_##CBNAME(const wxString& a);
  
-
  #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
      bool CLASS::CBNAME(const wxString& a)  {                                    \
          bool rval=FALSE;                                                        \
          bool found;                                                             \
  #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
      bool CLASS::CBNAME(const wxString& a)  {                                    \
          bool rval=FALSE;                                                        \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));\
-        wxPyEndBlockThreads(state);                                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));\
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
@@ -869,14 +879,14 @@ public:
  
  #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \
      bool CBNAME(const wxString& a);
  
  #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \
      bool CBNAME(const wxString& a);
-                   \
+
  #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME)                          \
      bool CLASS::CBNAME(const wxString& a)  {                                            \
          bool rval=FALSE;                                                                \
  #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME)                          \
      bool CLASS::CBNAME(const wxString& a)  {                                            \
          bool rval=FALSE;                                                                \
-        wxPyTState* state = wxPyBeginBlockThreads();                                    \
+        wxPyBeginBlockThreads();                                    \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                    \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                    \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));     \
-        wxPyEndBlockThreads(state);                                                     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));     \
+        wxPyEndBlockThreads();                                                     \
          return rval;                                                                    \
      }                                                                                   \
  
          return rval;                                                                    \
      }                                                                                   \
  
@@ -888,17 +898,16 @@ public:
  #define IMP_PYCALLBACK_STRING_STRING_pure(CLASS, PCLASS, CBNAME)                \
      wxString CLASS::CBNAME(const wxString& a)  {                                \
          wxString rval;                                                          \
  #define IMP_PYCALLBACK_STRING_STRING_pure(CLASS, PCLASS, CBNAME)                \
      wxString CLASS::CBNAME(const wxString& a)  {                                \
          wxString rval;                                                          \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(s)", a.c_str()));\
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));\
              if (ro) {                                                           \
              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;                                                            \
      }                                                                           \
  
@@ -910,17 +919,16 @@ public:
  #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME)             \
      wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
          wxString rval;                                                          \
  #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME)             \
      wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
          wxString rval;                                                          \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(si)", a.c_str(),b));  \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oi)", wx2PyString(a),b));  \
              if (ro) {                                                           \
              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;                                                            \
      }                                                                           \
  
@@ -930,16 +938,15 @@ public:
      bool CBNAME(const wxString& a, const wxString& b);        \
      bool base_##CBNAME(const wxString& a, const wxString& b);
  
      bool CBNAME(const wxString& a, const wxString& b);        \
      bool base_##CBNAME(const wxString& a, const wxString& b);
  
-
  #define IMP_PYCALLBACK_BOOL_STRINGSTRING(CLASS, PCLASS, CBNAME)                 \
      bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \
          bool rval=FALSE;                                                        \
          bool found;                                                             \
  #define IMP_PYCALLBACK_BOOL_STRINGSTRING(CLASS, PCLASS, CBNAME)                 \
      bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \
          bool rval=FALSE;                                                        \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ss)",         \
-                                                       a.c_str(), b.c_str()));  \
-        wxPyEndBlockThreads(state);                                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",         \
+                                                       wx2PyString(a), wx2PyString(b)));  \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b);                                        \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b);                                        \
          return rval;                                                            \
@@ -954,22 +961,20 @@ public:
      wxString CBNAME();                                  \
      wxString base_##CBNAME();
  
      wxString CBNAME();                                  \
      wxString base_##CBNAME();
  
-
  #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
      wxString CLASS::CBNAME() {                                                  \
          wxString rval;                                                          \
          bool found;                                                             \
  #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
      wxString CLASS::CBNAME() {                                                  \
          wxString rval;                                                          \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
              if (ro) {                                                           \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
              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();                                            \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME();                                            \
          return rval;                                                            \
@@ -983,21 +988,19 @@ public:
  #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
      wxString CBNAME();
  
  #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
      wxString CBNAME();
  
-
  #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
      wxString CLASS::CBNAME() {                                                  \
          wxString rval;                                                          \
  #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
      wxString CLASS::CBNAME() {                                                  \
          wxString rval;                                                          \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
              if (ro) {                                                           \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
              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;                                                            \
      }
  
@@ -1010,13 +1013,13 @@ public:
  #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
      bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
          bool rval=FALSE;                                                        \
  #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
      bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
          bool rval=FALSE;                                                        \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* obj = wxPyConstructObject((void*)&a, "wxHtmlTag", 0);     \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* obj = wxPyConstructObject((void*)&a, "wxHtmlTag", 0);     \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          return rval;                                                            \
      }
  
          return rval;                                                            \
      }
  
@@ -1028,15 +1031,14 @@ public:
  
  #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
      void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
  
  #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
      void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
-        wxString rval;                                                          \
          bool found;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
              wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y));  \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
              wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y));  \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(cell, x, y);                                         \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(cell, x, y);                                         \
      }                                                                           \
@@ -1054,7 +1056,7 @@ public:
  #define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
      void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
          bool found;                                                             \
  #define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
      void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
              PyObject* o2  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0);  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
              PyObject* o2  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0);  \
@@ -1062,7 +1064,7 @@ public:
              Py_DECREF(obj);                                                     \
              Py_DECREF(o2);                                                      \
          }                                                                       \
              Py_DECREF(obj);                                                     \
              Py_DECREF(o2);                                                      \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              PCLASS::CBNAME(cell, x, y, e);                                         \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(cell, x, y, e);                                         \
      }                                                                           \
@@ -1080,10 +1082,10 @@ public:
  
  #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
      void CLASS::CBNAME() {                                                      \
  
  #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
      void CLASS::CBNAME() {                                                      \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
      }
  
  //---------------------------------------------------------------------------
      }
  
  //---------------------------------------------------------------------------
@@ -1094,8 +1096,9 @@ public:
  
  #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME)                      \
      wxSize CLASS::CBNAME() {                                                    \
  
  #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME)                      \
      wxSize CLASS::CBNAME() {                                                    \
+        const char* errmsg = #CBNAME " should return a 2-tuple of integers or a wxSize object."; \
          wxSize rval(0,0);                                                       \
          wxSize rval(0,0);                                                       \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
              wxSize*   ptr;                                                      \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
              PyObject* ro;                                                       \
              wxSize*   ptr;                                                      \
@@ -1103,10 +1106,23 @@ public:
              if (ro) {                                                           \
                  if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))           \
                      rval = *ptr;                                                \
              if (ro) {                                                           \
                  if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))           \
                      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;                                                            \
      }
  
          return rval;                                                            \
      }
  
@@ -1121,13 +1137,13 @@ public:
      bool CLASS::CBNAME(wxWindow* a) {                                           \
          bool rval=FALSE;                                                        \
          bool found;                                                             \
      bool CLASS::CBNAME(wxWindow* a) {                                           \
          bool rval=FALSE;                                                        \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                            \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(a);                               \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyMake_wxObject(a);                               \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                             \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
@@ -1147,10 +1163,10 @@ public:
      bool CLASS::CBNAME() {                                                      \
          bool rval=FALSE;                                                        \
          bool found;                                                             \
      bool CLASS::CBNAME() {                                                      \
          bool rval=FALSE;                                                        \
          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;                                                            \
@@ -1170,10 +1186,10 @@ public:
      wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {          \
          int rval=0;                                                             \
          bool found;                                                             \
      wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {          \
          int rval=0;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b, c);                                     \
          return (wxDragResult)rval;                                              \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a, b, c);                                     \
          return (wxDragResult)rval;                                              \
@@ -1189,20 +1205,20 @@ public:
  
  #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
      wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
  
  #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
      wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                                        \
          wxFSFile* rval=0;                                               \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \
              PyObject* ro;                                               \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
          wxFSFile* rval=0;                                               \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \
              PyObject* ro;                                               \
              PyObject* obj = wxPyMake_wxObject(&a);                      \
-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Os)",\
-                                          obj, b.c_str()));             \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)",\
+                                          obj, wx2PyString(b)));        \
              if (ro) {                                                   \
                  SWIG_GetPtrObj(ro, (void **)&rval, "_wxFSFILE_p");      \
                  Py_DECREF(ro);                                          \
              }                                                           \
              Py_DECREF(obj);                                             \
          }                                                               \
              if (ro) {                                                   \
                  SWIG_GetPtrObj(ro, (void **)&rval, "_wxFSFILE_p");      \
                  Py_DECREF(ro);                                          \
              }                                                           \
              Py_DECREF(obj);                                             \
          }                                                               \
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                          \
          return rval;                                                    \
      };
  
          return rval;                                                    \
      };
  
@@ -1217,10 +1233,10 @@ public:
      bool CLASS::CBNAME(wxDragResult a) {                                \
          bool rval=FALSE;                                                \
          bool found;                                                     \
      bool CLASS::CBNAME(wxDragResult a) {                                \
          bool rval=FALSE;                                                \
          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;                                                    \
@@ -1237,11 +1253,11 @@ public:
  
  #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)            \
      wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
  
  #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)            \
      wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                                        \
          int rval=0;                                                     \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
          int rval=0;                                                     \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
              rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
-        wxPyEndBlockThreads(state);                                     \
+        wxPyEndBlockThreads();                                          \
          return (wxDragResult)rval;                                      \
      }                                                                   \
  
          return (wxDragResult)rval;                                      \
      }                                                                   \
  
@@ -1250,14 +1266,13 @@ public:
  #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \
      bool CBNAME(int a, int b, const wxString& c);
  
  #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \
      bool CBNAME(int a, int b, const wxString& c);
  
-
  #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
      bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
          bool rval=FALSE;                                                \
  #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
      bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
          bool rval=FALSE;                                                \
-        wxPyTState* state = wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                                        \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
          if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
-        wxPyEndBlockThreads(state);                                     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b, wx2PyString(c)));\
+        wxPyEndBlockThreads();                                          \
          return rval;                                                    \
      }                                                                   \
  
          return rval;                                                    \
      }                                                                   \
  
@@ -1272,10 +1287,10 @@ public:
      size_t CLASS::CBNAME() {                                                    \
          size_t rval=0;                                                          \
          bool found;                                                             \
      size_t CLASS::CBNAME() {                                                    \
          size_t rval=0;                                                          \
          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;                                                            \
@@ -1295,7 +1310,7 @@ public:
      wxDataFormat CLASS::CBNAME(size_t a) {                                      \
          wxDataFormat rval=0;                                                    \
          bool found;                                                             \
      wxDataFormat CLASS::CBNAME(size_t a) {                                      \
          wxDataFormat rval=0;                                                    \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              wxDataFormat* ptr;                                                  \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              wxDataFormat* ptr;                                                  \
@@ -1306,7 +1321,7 @@ public:
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
@@ -1325,13 +1340,13 @@ public:
  #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
      void CLASS::CBNAME(const Type& a) {                                         \
          bool found;                                                             \
  #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
      void CLASS::CBNAME(const Type& a) {                                         \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(a);                                                  \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a);                                                  \
      }                                                                           \
@@ -1350,13 +1365,13 @@ public:
  #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
      void CLASS::CBNAME(Type& a) {                                               \
          bool found;                                                             \
  #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
      void CLASS::CBNAME(Type& a) {                                               \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
              wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              PCLASS::CBNAME(a);                                                  \
      }                                                                           \
          if (! found)                                                            \
              PCLASS::CBNAME(a);                                                  \
      }                                                                           \
@@ -1373,15 +1388,15 @@ public:
  
  #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
      bool CLASS::CBNAME(Type& a) {                                               \
  
  #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
      bool CLASS::CBNAME(Type& a) {                                               \
-        bool rv;                                                                \
+        bool rv=FALSE;                                                          \
          bool found;                                                             \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
              rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
              Py_DECREF(obj);                                                     \
          }                                                                       \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
              rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
              Py_DECREF(obj);                                                     \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rv = PCLASS::CBNAME(a);                                             \
          return rv;                                                              \
          if (! found)                                                            \
              rv = PCLASS::CBNAME(a);                                             \
          return rv;                                                              \
@@ -1396,22 +1411,20 @@ public:
      wxString CBNAME(long a, long b) const;                                      \
      wxString base_##CBNAME(long a, long b)const ;
  
      wxString CBNAME(long a, long b) const;                                      \
      wxString base_##CBNAME(long a, long b)const ;
  
-
  #define IMP_PYCALLBACK_STRING_LONGLONG(CLASS, PCLASS, CBNAME)                   \
      wxString CLASS::CBNAME(long a, long b) const {                              \
          wxString rval;                                                          \
          bool found;                                                             \
  #define IMP_PYCALLBACK_STRING_LONGLONG(CLASS, PCLASS, CBNAME)                   \
      wxString CLASS::CBNAME(long a, long b) const {                              \
          wxString rval;                                                          \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \
              if (ro) {                                                           \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",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;                                                            \
@@ -1431,7 +1444,7 @@ public:
      int CLASS::CBNAME(long a) const {                                           \
          int rval=-1;                                                            \
          bool found;                                                             \
      int CLASS::CBNAME(long a) const {                                           \
          int rval=-1;                                                            \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
@@ -1440,7 +1453,7 @@ public:
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
@@ -1461,7 +1474,7 @@ public:
      wxListItemAttr *CLASS::CBNAME(long a) const {                               \
          wxListItemAttr *rval = NULL;                                            \
          bool found;                                                             \
      wxListItemAttr *CLASS::CBNAME(long a) const {                               \
          wxListItemAttr *rval = NULL;                                            \
          bool found;                                                             \
-        wxPyTState* state = wxPyBeginBlockThreads();                            \
+        wxPyBeginBlockThreads();                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              wxListItemAttr* ptr;                                                \
          if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
              PyObject* ro;                                                       \
              wxListItemAttr* ptr;                                                \
@@ -1472,7 +1485,7 @@ public:
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
                  Py_DECREF(ro);                                                  \
              }                                                                   \
          }                                                                       \
-        wxPyEndBlockThreads(state);                                             \
+        wxPyEndBlockThreads();                                                  \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
          if (! found)                                                            \
              rval = PCLASS::CBNAME(a);                                           \
          return rval;                                                            \
@@ -1483,31 +1496,32 @@ public:
  
  //---------------------------------------------------------------------------
  
  
  //---------------------------------------------------------------------------
  
-#define DEC_PYCALLBACK_BOOL_ME(CBNAME) \
-    bool CBNAME(wxMouseEvent& e); \
+#define DEC_PYCALLBACK_BOOL_ME(CBNAME)                                          \
+    bool CBNAME(wxMouseEvent& e);                                               \
      bool base_##CBNAME(wxMouseEvent& e);
  
      bool base_##CBNAME(wxMouseEvent& e);
  
-#define IMP_PYCALLBACK_BOOL_ME(CLASS, PCLASS, CBNAME) \
-    bool CLASS::CBNAME(wxMouseEvent& e) { \
-        bool rval; \
-        bool found; \
-        wxPyTState* state = wxPyBeginBlockThreads(); \
-        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
-            PyObject* ro; \
-            PyObject* obj  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0);  \
-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj));  \
-            if (ro) { \
-                rval = PyInt_AsLong(ro); \
-                Py_DECREF(ro); \
-            } \
-            Py_DECREF(obj); \
-        } \
-        wxPyEndBlockThreads(state); \
-        if (! found) \
-            return PCLASS::CBNAME(e); \
-    } \
-    bool CLASS::base_##CBNAME(wxMouseEvent& e) { \
-        return PCLASS::CBNAME(e); \
+#define IMP_PYCALLBACK_BOOL_ME(CLASS, PCLASS, CBNAME)                           \
+    bool CLASS::CBNAME(wxMouseEvent& e) {                                       \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            PyObject* obj  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0); \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj));   \
+            if (ro) {                                                           \
+                rval = PyInt_AsLong(ro);                                        \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            return PCLASS::CBNAME(e);                                           \
+        return rval;                                                            \
+    }                                                                           \
+    bool CLASS::base_##CBNAME(wxMouseEvent& e) {                                \
+        return PCLASS::CBNAME(e);                                               \
      }
  
  
      }