fix text scrolling in GTK2 (patch 703988)

[wxWidgets.git] / wxPython / src / helpers.h

diff --git a/wxPython/src/helpers.h b/wxPython/src/helpers.h
index b542b5f2b419e70faf8b8f854ab6a0673fc24723..17c73fae138daa5457d2c998a096b24223cf97bf 100644 (file)
--- a/wxPython/src/helpers.h
+++ b/wxPython/src/helpers.h
@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////////////////////////////////
 // Name:        helpers.h
 ////////////////////////////////////////////////////////////////////////////
 // Name:        helpers.h

-// Purpose:     Helper functions/classes for the wxPython extenaion module
+// Purpose:     Helper functions/classes for the wxPython extension module

 //
 // Author:      Robin Dunn
 //
 //
 // Author:      Robin Dunn
 //


@@ -14,108 +14,77 @@
 #define __wxp_helpers__
 
 #include <wx/wx.h>
 #define __wxp_helpers__
 
 #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
-
+#include <wx/geometry.h>

 
 //---------------------------------------------------------------------------
 
 typedef unsigned char byte;
 
 
 //---------------------------------------------------------------------------
 
 typedef unsigned char byte;
 

-
-class wxPyApp: public wxApp
-{
-public:
-    wxPyApp();
-    ~wxPyApp();
-    int  MainLoop(void);
-    bool OnInit(void);
-};
-extern wxPyApp *wxPythonApp;
-
-//----------------------------------------------------------------------
-
-void      __wxPreStart();
+void      __wxPreStart(PyObject*);

 PyObject* __wxStart(PyObject*, PyObject* args);
 void      __wxCleanup();
 
 PyObject* __wxStart(PyObject*, PyObject* args);
 void      __wxCleanup();
 

-extern PyObject* wxPython_dict;
+//extern PyObject* wxPython_dict;

 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
 
 void wxPyEventThunker(wxObject*, wxEvent& event);
 
 PyObject* wxPyConstructObject(void* ptr,
 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
 
 void wxPyEventThunker(wxObject*, wxEvent& event);
 
 PyObject* wxPyConstructObject(void* ptr,

-                              const char* className,
+                              const wxString& className,
+                              int setThisOwn=0);
+PyObject* wxPyConstructObject(void* ptr,
+                              const wxString& className,
+                              PyObject* klass,

                               int setThisOwn=0);
                               int setThisOwn=0);

-bool wxPyRestoreThread();
-void wxPySaveThread(bool doSave);
+
+PyObject* wx2PyString(const wxString& src);
+wxString  Py2wxString(PyObject* source);
+
+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);
 PyObject* wxPy_ConvertList(wxListBase* list, const char* className);

-long wxPyGetWinHandle(wxWindow* win);
+long      wxPyGetWinHandle(wxWindow* win);

 
 

+void wxPy_ReinitStockObjects();

 
 
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------

-// 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;
+// For Python --> C++
+PyThreadState* wxPyBeginAllowThreads();
+void           wxPyEndAllowThreads(PyThreadState* state);

 
 

-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 C++ --> Python
+void wxPyBeginBlockThreads();
+void wxPyEndBlockThreads();

 
 

+#define wxPyBLOCK_THREADS(stmt) wxPyBeginBlockThreads(); stmt; 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);
 char** string_LIST_helper(PyObject* source);
 byte* byte_LIST_helper(PyObject* source);
 int* int_LIST_helper(PyObject* source);
 long* long_LIST_helper(PyObject* source);
 char** string_LIST_helper(PyObject* source);

-wxPoint* wxPoint_LIST_helper(PyObject* source);
+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);


@@ -123,6 +92,43 @@ 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);
 

+bool wxPoint2DDouble_helper(PyObject* source, wxPoint2DDouble** 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 wxPy2int_seq_helper(PyObject* source, int* i1, int* i2);
+bool wxPy4int_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)
+
+//----------------------------------------------------------------------
+// functions used by the DrawXXXList enhancements added to wxDC
+
+typedef bool (*wxPyDrawListOp_t)(wxDC& dc, PyObject* coords);
+PyObject* wxPyDrawXXXList(wxDC& dc, wxPyDrawListOp_t doDraw,
+                          PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes);
+bool wxPyDrawXXXPoint(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXLine(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXRectangle(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXEllipse(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXPolygon(wxDC& dc, PyObject* coords);
+
+PyObject* wxPyDrawTextList(wxDC& dc, PyObject* textList, PyObject* pyPoints,
+                           PyObject* foregroundList, PyObject* backgroundList);
+

 //----------------------------------------------------------------------
 
 #ifndef SWIGCODE
 //----------------------------------------------------------------------
 
 #ifndef SWIGCODE


@@ -137,13 +143,6 @@ extern "C" char *SWIG_GetPtrObj(PyObject *obj, void **ptr, char *type);
 # pragma warning(disable:4190)
 #endif
 
 # pragma warning(disable:4190)
 #endif
 

-
-
-// Non-const versions to keep SWIG happy.
-extern wxPoint  wxPyDefaultPosition;
-extern wxSize   wxPyDefaultSize;
-extern wxString wxPyEmptyStr;
-

 //----------------------------------------------------------------------
 
 class wxPyCallback : public wxObject {
 //----------------------------------------------------------------------
 
 class wxPyCallback : public wxObject {


@@ -185,6 +184,7 @@ public:
 
     void SetSelf(PyObject* self, bool clone=FALSE);
     PyObject* GetSelf() const;
 
     void SetSelf(PyObject* self, bool clone=FALSE);
     PyObject* GetSelf() const;

+    bool GetCloned() const { return m_cloned; }

 
 protected:
     PyObject*   m_self;
 
 protected:
     PyObject*   m_self;


@@ -193,25 +193,41 @@ protected:
 
 
 class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
 
 
 class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {

-    DECLARE_DYNAMIC_CLASS(wxPyEvent)
+    DECLARE_ABSTRACT_CLASS(wxPyEvent)

 public:
 public:

-    wxPyEvent(int id=0);
+    wxPyEvent(int winid=0, wxEventType commandType = wxEVT_NULL);
+    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;
+class wxPyCBInputStream;
+
+void wxPyClientData_dtor(wxPyClientData* self);
+void wxPyUserData_dtor(wxPyUserData* self);
+void wxPyOORClientData_dtor(wxPyOORClientData* self);
+wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block);
+
+

 //---------------------------------------------------------------------------
 // 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


@@ -219,25 +235,42 @@ public:
 
 class wxPyCallbackHelper;
 
 
 class wxPyCallbackHelper;
 

+
+// Make SunCC happy and make typedef's for these that are extern "C"
+typedef void        (*p_SWIG_MakePtr_t)(char*, void*, char*);
+typedef char*       (*p_SWIG_GetPtr_t)(char*, void**, char*);
+typedef char*       (*p_SWIG_GetPtrObj_t)(PyObject*, void**, char*);
+typedef void        (*p_SWIG_RegisterMapping_t)(char*, char*, void *(*cast)(void *));
+typedef void        (*p_SWIG_addvarlink_t)(PyObject*, char*, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p));
+typedef PyObject*   (*p_SWIG_newvarlink_t)(void);
+
+

 struct wxPyCoreAPI {
 
 struct wxPyCoreAPI {
 

-    void        (*p_SWIG_MakePtr)(char*, void*, char*);
-    char*       (*p_SWIG_GetPtr)(char*, void**, char*);
-    char*       (*p_SWIG_GetPtrObj)(PyObject*, void**, char*);
-    void        (*p_SWIG_RegisterMapping)(char*, char*, void *(*cast)(void *));
-    void        (*p_SWIG_addvarlink)(PyObject*, char*, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p));
-    PyObject*   (*p_SWIG_newvarlink)(void);
+    p_SWIG_MakePtr_t           p_SWIG_MakePtr;
+    p_SWIG_GetPtr_t            p_SWIG_GetPtr;
+    p_SWIG_GetPtrObj_t         p_SWIG_GetPtrObj;
+    p_SWIG_RegisterMapping_t   p_SWIG_RegisterMapping;
+    p_SWIG_addvarlink_t        p_SWIG_addvarlink;
+    p_SWIG_newvarlink_t        p_SWIG_newvarlink;
+
+    PyThreadState* (*p_wxPyBeginAllowThreads)();
+    void           (*p_wxPyEndAllowThreads)(PyThreadState* state);
+    void        (*p_wxPyBeginBlockThreads)();
+    void        (*p_wxPyEndBlockThreads)();

 
 

-    void        (*p_wxPySaveThread)(bool);
-    bool        (*p_wxPyRestoreThread)();
-    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);
     char**      (*p_string_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);
     char**      (*p_string_LIST_helper)(PyObject* source);

-    wxPoint*    (*p_wxPoint_LIST_helper)(PyObject* source);
+    wxPoint*    (*p_wxPoint_LIST_helper)(PyObject* source, int* npoints);

     wxBitmap**  (*p_wxBitmap_LIST_helper)(PyObject* source);
     wxString*   (*p_wxString_LIST_helper)(PyObject* source);
     wxAcceleratorEntry*   (*p_wxAcceleratorEntry_LIST_helper)(PyObject* source);
     wxBitmap**  (*p_wxBitmap_LIST_helper)(PyObject* source);
     wxString*   (*p_wxString_LIST_helper)(PyObject* source);
     wxAcceleratorEntry*   (*p_wxAcceleratorEntry_LIST_helper)(PyObject* source);


@@ -247,18 +280,88 @@ struct wxPyCoreAPI {
     bool        (*p_wxRealPoint_helper)(PyObject* source, wxRealPoint** obj);
     bool        (*p_wxRect_helper)(PyObject* source, wxRect** obj);
     bool        (*p_wxColour_helper)(PyObject* source, wxColour** obj);
     bool        (*p_wxRealPoint_helper)(PyObject* source, wxRealPoint** obj);
     bool        (*p_wxRect_helper)(PyObject* source, wxRect** obj);
     bool        (*p_wxColour_helper)(PyObject* source, wxColour** obj);

+    bool        (*p_wxPoint2DDouble_helper)(PyObject* source, wxPoint2DDouble** obj);

 
 

-    void        (*p_wxPyCBH_setSelf)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
+    void        (*p_wxPyCBH_setCallbackInfo)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);

     bool        (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
     int         (*p_wxPyCBH_callCallback)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
     PyObject*   (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
     void        (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
 
     bool        (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
     int         (*p_wxPyCBH_callCallback)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
     PyObject*   (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
     void        (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
 

+    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);
+    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*);
+
+    wxPyCBInputStream* (*p_wxPyCBInputStream_create)(PyObject *py, bool block);
+
+};
+
+#ifdef wxPyUSE_EXPORT
+// Notice that this is static, not extern.  This is by design, each module
+// needs one, but doesn't have to use it.
+static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;
+#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
 #ifdef wxPyUSE_EXPORT

-static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;  // Each module needs one, but may not use it.
+        wxPyCoreAPIPtr->p_wxPyOORClientData_dtor(this);
+#else
+        wxPyOORClientData_dtor(this);

 #endif
 #endif

+    }
+};

 
 //---------------------------------------------------------------------------
 // This class holds an instance of a Python Shadow Class object and assists
 
 //---------------------------------------------------------------------------
 // This class holds an instance of a Python Shadow Class object and assists


@@ -302,7 +405,7 @@ private:
 };
 
 
 };
 
 

-void wxPyCBH_setSelf(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
+void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);

 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name);
 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name);
 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);


@@ -310,80 +413,115 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 
 
 
 
 

-//----------------------------------------------------------------------

 
 

-class wxPyUserData : public wxObject {
-public:
-    wxPyUserData(PyObject* obj) {
-        m_obj = obj;
-        Py_INCREF(m_obj);
-    }
+//---------------------------------------------------------------------------

 
 

-    ~wxPyUserData() {
-        bool doSave;
-#ifdef wxPyUSE_EXPORT
-        doSave = wxPyCoreAPIPtr->p_wxPyRestoreThread();
-        Py_DECREF(m_obj);
-        wxPyCoreAPIPtr->p_wxPySaveThread(doSave);
-#else
-        doSave = wxPyRestoreThread();
-        Py_DECREF(m_obj);
-        wxPySaveThread(doSave);
+// This is used in C++ classes that need to be able to make callback to
+// "overloaded" python methods
+
+#define PYPRIVATE                                                               \
+    void _setCallbackInfo(PyObject* self, PyObject* _class, int incref=1) {     \
+        wxPyCBH_setCallbackInfo(m_myInst, self, _class, incref);                \
+    }                                                                           \
+    private: wxPyCallbackHelper m_myInst
+
+
+//---------------------------------------------------------------------------
+
+enum {
+    wxPYAPP_ASSERT_SUPPRESS  = 1,
+    wxPYAPP_ASSERT_EXCEPTION = 2,
+    wxPYAPP_ASSERT_DIALOG    = 4,
+    wxPYAPP_ASSERT_LOG       = 8
+};
+
+class wxPyApp: public wxApp
+{
+    DECLARE_ABSTRACT_CLASS(wxPyApp);
+
+public:
+    wxPyApp();
+    ~wxPyApp();
+    bool OnInit();
+    int  MainLoop();
+
+    int  GetAssertMode() { return m_assertMode; }
+    void SetAssertMode(int mode) { m_assertMode = mode; }
+
+    virtual bool OnInitGui();
+    virtual int OnExit();
+#ifdef __WXDEBUG__
+    virtual void OnAssert(const wxChar *file,
+                          int line,
+                          const wxChar *cond,
+                          const wxChar *msg);

 #endif
 #endif

-    }
-    PyObject* m_obj;
+    // virtual int FilterEvent(wxEvent& event); // This one too????
+
+
+    static bool GetMacDefaultEncodingIsPC();
+    static bool GetMacSupportPCMenuShortcuts();
+    static long GetMacAboutMenuItemId();
+    static long GetMacPreferencesMenuItemId();
+    static long GetMacExitMenuItemId();
+    static wxString GetMacHelpMenuTitleName();
+
+    static void SetMacDefaultEncodingIsPC(bool val);
+    static void SetMacSupportPCMenuShortcuts(bool val);
+    static void SetMacAboutMenuItemId(long val);
+    static void SetMacPreferencesMenuItemId(long val);
+    static void SetMacExitMenuItemId(long val);
+    static void SetMacHelpMenuTitleName(const wxString& val);
+
+
+    PYPRIVATE;
+    int m_assertMode;

 };
 
 };
 

+extern wxPyApp *wxPythonApp;

 
 
 
 

-//---------------------------------------------------------------------------
+//----------------------------------------------------------------------

 // These macros are used to implement the virtual methods that should
 // redirect to a Python method if one exists.  The names designate the
 // return type, if any, as well as any parameter types.
 //---------------------------------------------------------------------------
 
 // These macros are used to implement the virtual methods that should
 // redirect to a Python method if one exists.  The names designate the
 // return type, if any, as well as any parameter types.
 //---------------------------------------------------------------------------
 

-#define PYPRIVATE                                                       \
-    void _setSelf(PyObject* self, PyObject* _class, int incref=1) {     \
-        wxPyCBH_setSelf(m_myInst, self, _class, incref);                \
-    }                                                                   \
-    private: wxPyCallbackHelper m_myInst
-
-//---------------------------------------------------------------------------
-

 #define DEC_PYCALLBACK__(CBNAME)                        \
     void CBNAME();                                      \
 #define DEC_PYCALLBACK__(CBNAME)                        \
     void CBNAME();                                      \

-    void base_##CBNAME();
-
-
-#define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)         \
-    void CLASS::CBNAME() {                              \
-        bool doSave = wxPyRestoreThread();              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))             \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
-        else                                            \
-            PCLASS::CBNAME();                           \
-        wxPySaveThread(doSave);                         \
-    }                                                   \
-    void CLASS::base_##CBNAME() {                       \
-        PCLASS::CBNAME();                               \
+    void base_##CBNAME()
+
+
+#define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)                         \
+    void CLASS::CBNAME() {                                              \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));        \
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            PCLASS::CBNAME();                                           \
+    }                                                                   \
+    void CLASS::base_##CBNAME() {                                       \
+        PCLASS::CBNAME();                                               \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
     bool CBNAME(int a, int b);                                  \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
     bool CBNAME(int a, int b);                                  \

-    bool base_##CBNAME(int a, int b);
+    bool base_##CBNAME(int a, int b)

 
 
 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
     bool CLASS::CBNAME(int a, int b) {                                  \
 
 
 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
     bool CLASS::CBNAME(int a, int b) {                                  \

-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+        bool rval=FALSE, found;                                         \
+        wxPyBeginBlockThreads();                    \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \

             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \

-        else                                                            \
+        wxPyEndBlockThreads();                                     \
+        if (! found)                                                    \

             rval = PCLASS::CBNAME(a,b);                                 \
             rval = PCLASS::CBNAME(a,b);                                 \

-        wxPySaveThread(doSave);                                         \

         return rval;                                                    \
     }                                                                   \
     bool CLASS::base_##CBNAME(int a, int b) {                           \
         return rval;                                                    \
     }                                                                   \
     bool CLASS::base_##CBNAME(int a, int b) {                           \


@@ -392,19 +530,41 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

+#define DEC_PYCALLBACK_VOID_(CBNAME)                    \
+    void CBNAME();                                      \
+    void base_##CBNAME()
+
+
+#define IMP_PYCALLBACK_VOID_(CLASS, PCLASS, CBNAME)                     \
+    void CLASS::CBNAME() {                                              \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));        \
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            PCLASS::CBNAME();                                           \
+    }                                                                   \
+    void CLASS::base_##CBNAME() {                                       \
+        PCLASS::CBNAME();                                               \
+    }
+
+//---------------------------------------------------------------------------
+

 #define DEC_PYCALLBACK_VOID_INTINT(CBNAME)                      \
     void CBNAME(int a, int b);                                  \
 #define DEC_PYCALLBACK_VOID_INTINT(CBNAME)                      \
     void CBNAME(int a, int b);                                  \

-    void base_##CBNAME(int a, int b);
+    void base_##CBNAME(int a, int b)

 
 
 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
     void CLASS::CBNAME(int a, int b) {                                  \
 
 
 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
     void CLASS::CBNAME(int a, int b) {                                  \

-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));           \
-        else                                                            \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));  \
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \

             PCLASS::CBNAME(a,b);                                        \
             PCLASS::CBNAME(a,b);                                        \

-        wxPySaveThread(doSave);                                         \

     }                                                                   \
     void CLASS::base_##CBNAME(int a, int b) {                           \
         PCLASS::CBNAME(a,b);                                            \
     }                                                                   \
     void CLASS::base_##CBNAME(int a, int b) {                           \
         PCLASS::CBNAME(a,b);                                            \


@@ -412,20 +572,190 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

+#define DEC_PYCALLBACK_VOID_INT(CBNAME)                         \
+    void CBNAME(int a);                                         \
+    void base_##CBNAME(int a)
+
+
+#define IMP_PYCALLBACK_VOID_INT(CLASS, PCLASS, CBNAME)                  \
+    void CLASS::CBNAME(int a) {                                         \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));     \
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            PCLASS::CBNAME(a);                                          \
+    }                                                                   \
+    void CLASS::base_##CBNAME(int a) {                                  \
+        PCLASS::CBNAME(a);                                              \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_VOID_INT4(CBNAME)                                \
+    void CBNAME(int a, int b, int c, int d);                            \
+    void base_##CBNAME(int a, int b, int c, int d)
+
+
+#define IMP_PYCALLBACK_VOID_INT4(CLASS, PCLASS, CBNAME)                 \
+    void CLASS::CBNAME(int a, int b, int c, int d) {                    \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiii)",a,b,c,d));  \
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            PCLASS::CBNAME(a,b,c,d);                                    \
+    }                                                                   \
+    void CLASS::base_##CBNAME(int a, int b, int c, int d) {             \
+        PCLASS::CBNAME(a,b,c,d);                                        \
+    }
+
+//---------------------------------------------------------------------------
+#define DEC_PYCALLBACK_VOID_INT5(CBNAME)                                \
+    void CBNAME(int a, int b, int c, int d, int e);                     \
+    void base_##CBNAME(int a, int b, int c, int d, int e)
+
+
+#define IMP_PYCALLBACK_VOID_INT5(CLASS, PCLASS, CBNAME)                 \
+    void CLASS::CBNAME(int a, int b, int c, int d, int e) {             \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiiii)",a,b,c,d,e));  \
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            PCLASS::CBNAME(a,b,c,d,e);                                  \
+    }                                                                   \
+    void CLASS::base_##CBNAME(int a, int b, int c, int d, int e) {      \
+        PCLASS::CBNAME(a,b,c,d,e);                                      \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_VOID_INTPINTP_const(CBNAME)                              \
+    void CBNAME(int* a, int* b) const;                                          \
+    void base_##CBNAME(int* a, int* b) const
+
+
+#define IMP_PYCALLBACK_VOID_INTPINTP_const(CLASS, PCLASS, CBNAME)               \
+    void CLASS::CBNAME(int* a, int* b) const {                                  \
+        const char* errmsg = #CBNAME " should return a 2-tuple of integers.";   \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                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)) {             \
+                        *a = PyInt_AsLong(o1); *b = PyInt_AsLong(o2);           \
+                    }                                                           \
+                    else                                                        \
+                        PyErr_SetString(PyExc_TypeError, errmsg);               \
+                    Py_DECREF(o1);                                              \
+                    Py_DECREF(o2);                                              \
+                }                                                               \
+                else {                                                          \
+                    PyErr_SetString(PyExc_TypeError, errmsg);                   \
+                }                                                               \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,b);                                                \
+    }                                                                           \
+    void CLASS::base_##CBNAME(int* a, int* b) const {                           \
+        PCLASS::CBNAME(a,b);                                                    \
+    }
+
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_SIZE_const(CBNAME)                                       \
+    wxSize CBNAME() const;                                                      \
+    wxSize base_##CBNAME() const
+
+
+#define IMP_PYCALLBACK_SIZE_const(CLASS, PCLASS, CBNAME)                        \
+    wxSize CLASS::CBNAME() const {                                              \
+        const char* errmsg = #CBNAME " should return a 2-tuple of integers.";   \
+        bool found; wxSize rval(0,0);                                           \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                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);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            return PCLASS::CBNAME();                                            \
+        else                                                                    \
+            return rval;                                                        \
+    }                                                                           \
+    wxSize CLASS::base_##CBNAME() const {                                       \
+        return PCLASS::CBNAME();                                                \
+    }
+
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BOOL_BOOL(CBNAME)                         \
+    bool CBNAME(bool a);                                         \
+    bool base_##CBNAME(bool a)
+
+
+#define IMP_PYCALLBACK_BOOL_BOOL(CLASS, PCLASS, CBNAME)                 \
+    bool CLASS::CBNAME(bool a) {                                        \
+        bool rval=FALSE, found;                                         \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            rval = PCLASS::CBNAME(a);                                   \
+        return rval;                                                    \
+    }                                                                   \
+    bool CLASS::base_##CBNAME(bool a) {                                 \
+        return PCLASS::CBNAME(a);                                       \
+    }
+
+//---------------------------------------------------------------------------
+

 #define DEC_PYCALLBACK_BOOL_INT(CBNAME)                         \
     bool CBNAME(int a);                                         \
 #define DEC_PYCALLBACK_BOOL_INT(CBNAME)                         \
     bool CBNAME(int a);                                         \

-    bool base_##CBNAME(int a);
+    bool base_##CBNAME(int a)

 
 
 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
     bool CLASS::CBNAME(int a) {                                         \
 
 
 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
     bool CLASS::CBNAME(int a) {                                         \

-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
-        else                                                            \
+        bool rval=FALSE, found;                                         \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \

             rval = PCLASS::CBNAME(a);                                   \
             rval = PCLASS::CBNAME(a);                                   \

-        wxPySaveThread(doSave);                                         \

         return rval;                                                    \
     }                                                                   \
     bool CLASS::base_##CBNAME(int a) {                                  \
         return rval;                                                    \
     }                                                                   \
     bool CLASS::base_##CBNAME(int a) {                                  \


@@ -435,17 +765,17 @@ public:
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \

-    bool CBNAME(int a);
+    bool CBNAME(int a)

 
 
 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
     bool CLASS::CBNAME(int a) {                                         \
 
 
 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
     bool CLASS::CBNAME(int a) {                                         \

-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+        bool rval=FALSE;                                                \
+        wxPyBeginBlockThreads();                    \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \

             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
         else rval = FALSE;                                              \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
         else rval = FALSE;                                              \

-        wxPySaveThread(doSave);                                         \
+        wxPyEndBlockThreads();                                     \

         return rval;                                                    \
     }
 
         return rval;                                                    \
     }
 


@@ -454,23 +784,24 @@ public:
 
 #define DEC_PYCALLBACK__DC(CBNAME)                      \
     void CBNAME(wxDC& a);                               \
 
 #define DEC_PYCALLBACK__DC(CBNAME)                      \
     void CBNAME(wxDC& a);                               \

-    void base_##CBNAME(wxDC& a);
+    void base_##CBNAME(wxDC& a)

 
 
 
 

-#define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)               \
-    void CLASS::CBNAME(wxDC& a) {                               \
-        bool doSave = wxPyRestoreThread();                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                   \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC", 0); \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
-            Py_DECREF(obj);                                     \
-        }                                                       \
-        else                                                    \
-            PCLASS::CBNAME(a);                                  \
-        wxPySaveThread(doSave);                                 \
-    }                                                           \
-    void CLASS::base_##CBNAME(wxDC& a) {                        \
-        PCLASS::CBNAME(a);                                      \
+#define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)                       \
+    void CLASS::CBNAME(wxDC& a) {                                       \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
+            PyObject* obj = wxPyMake_wxObject(&a);                      \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));  \
+            Py_DECREF(obj);                                             \
+        }                                                               \
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            PCLASS::CBNAME(a);                                          \
+    }                                                                   \
+    void CLASS::base_##CBNAME(wxDC& a) {                                \
+        PCLASS::CBNAME(a);                                              \

     }
 
 
     }
 
 


@@ -479,20 +810,21 @@ public:
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \

-    void base_##CBNAME(wxDC& a, bool b);
+    void base_##CBNAME(wxDC& a, bool b)

 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \

-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);         \
+        bool found;                                                     \
+        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);                                             \
         }                                                               \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
             Py_DECREF(obj);                                             \
         }                                                               \

-        else                                                            \
+        wxPyEndBlockThreads();                                     \
+        if (! found)                                                    \

             PCLASS::CBNAME(a, b);                                       \
             PCLASS::CBNAME(a, b);                                       \

-        wxPySaveThread(doSave);                                         \

     }                                                                   \
     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
         PCLASS::CBNAME(a, b);                                           \
     }                                                                   \
     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
         PCLASS::CBNAME(a, b);                                           \


@@ -502,20 +834,21 @@ public:
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
     void CBNAME(wxDC& a, bool b);                               \
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
     void CBNAME(wxDC& a, bool b);                               \

-    void base_##CBNAME(wxDC& a, bool b);
+    void base_##CBNAME(wxDC& a, bool b)

 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \

-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);         \
+        bool found;                                                     \
+        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);                                             \
         }                                                               \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
             Py_DECREF(obj);                                             \
         }                                                               \

-        else                                                            \
+        wxPyEndBlockThreads();                                     \
+        if (! found)                                                    \

             PCLASS::CBNAME(a, b);                                       \
             PCLASS::CBNAME(a, b);                                       \

-                wxPySaveThread(doSave);                                 \

     }                                                                   \
     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
         PCLASS::CBNAME(a, b);                                           \
     }                                                                   \
     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
         PCLASS::CBNAME(a, b);                                           \


@@ -525,38 +858,40 @@ public:
 
 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
     void CBNAME(double a, double b);                    \
 
 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
     void CBNAME(double a, double b);                    \

-    void base_##CBNAME(double a, double b);
+    void base_##CBNAME(double a, double b)

 
 
 
 

-#define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)             \
-    void CLASS::CBNAME(double a, double b) {                    \
-        bool doSave = wxPyRestoreThread();                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                     \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));   \
-        else                                                    \
-            PCLASS::CBNAME(a, b);                               \
-        wxPySaveThread(doSave);                                 \
-    }                                                           \
-    void CLASS::base_##CBNAME(double a, double b) {             \
-        PCLASS::CBNAME(a, b);                                   \
+#define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
+    void CLASS::CBNAME(double a, double b) {                            \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                    \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));  \
+        wxPyEndBlockThreads();                                     \
+        if (! found)                                                    \
+            PCLASS::CBNAME(a, b);                                       \
+    }                                                                   \
+    void CLASS::base_##CBNAME(double a, double b) {                     \
+        PCLASS::CBNAME(a, b);                                           \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
     void CBNAME(double a, double b, int c, int d);              \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
     void CBNAME(double a, double b, int c, int d);              \

-    void base_##CBNAME(double a, double b, int c, int d);
+    void base_##CBNAME(double a, double b, int c, int d)

 
 
 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(double a, double b, int c, int d) {              \
 
 
 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(double a, double b, int c, int d) {              \

-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",               \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                    \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",      \

                                                        a,b,c,d));       \
                                                        a,b,c,d));       \

-        else                                                            \
+        wxPyEndBlockThreads();                                     \
+        if (! found)                                                    \

             PCLASS::CBNAME(a, b, c, d);                                 \
             PCLASS::CBNAME(a, b, c, d);                                 \

-        wxPySaveThread(doSave);                                         \

     }                                                                   \
     void CLASS::base_##CBNAME(double a, double b, int c, int d) {       \
         PCLASS::CBNAME(a, b, c, d);                                     \
     }                                                                   \
     void CLASS::base_##CBNAME(double a, double b, int c, int d) {       \
         PCLASS::CBNAME(a, b, c, d);                                     \


@@ -564,22 +899,23 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

-#define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME)                              \
+#define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME)                                      \

     void CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
     void CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \

-    void base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
+    void base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f)

 
 
 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 
 
 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \

-        bool doSave = wxPyRestoreThread();                                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);                         \
+        bool found;                                                                     \
+        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);                                                             \
         }                                                                               \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
             Py_DECREF(obj);                                                             \
         }                                                                               \

-        else                                                                            \
+        wxPyEndBlockThreads();                                                     \
+        if (! found)                                                                    \

             PCLASS::CBNAME(a, b, c, d, e, f);                                           \
             PCLASS::CBNAME(a, b, c, d, e, f);                                           \

-        wxPySaveThread(doSave);                                                         \

     }                                                                                   \
     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
         PCLASS::CBNAME(a, b, c, d, e, f);                                               \
     }                                                                                   \
     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
         PCLASS::CBNAME(a, b, c, d, e, f);                                               \


@@ -589,21 +925,22 @@ public:
 
 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 
 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \

-    bool base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
+    bool base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f)

 
 
 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 
 
 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \

-        bool doSave = wxPyRestoreThread();                                              \
-        bool rval;                                                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);                         \
+        bool found;                                                                     \
+        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);                                                             \
         }                                                                               \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
             Py_DECREF(obj);                                                             \
         }                                                                               \

-        else                                                                            \
+        wxPyEndBlockThreads();                                                     \
+        if (! found)                                                                    \

             rval = PCLASS::CBNAME(a, b, c, d, e, f);                                    \
             rval = PCLASS::CBNAME(a, b, c, d, e, f);                                    \

-        wxPySaveThread(doSave);                                                         \

         return rval;                                                                    \
     }                                                                                   \
     bool CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
         return rval;                                                                    \
     }                                                                                   \
     bool CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\


@@ -614,18 +951,19 @@ public:
 
 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
     void CBNAME(bool a, double b, double c, int d, int e);              \
 
 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
     void CBNAME(bool a, double b, double c, int d, int e);              \

-    void base_##CBNAME(bool a, double b, double c, int d, int e);
+    void base_##CBNAME(bool a, double b, double c, int d, int e)

 
 
 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
 
 
 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(idii)",                       \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \

                                                 (int)a,b,c,d,e));               \
                                                 (int)a,b,c,d,e));               \

-        else                                                                    \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \

             PCLASS::CBNAME(a, b, c, d, e);                                      \
             PCLASS::CBNAME(a, b, c, d, e);                                      \

-        wxPySaveThread(doSave);                                                 \

     }                                                                           \
     void CLASS::base_##CBNAME(bool a, double b, double c, int d, int e) {       \
         PCLASS::CBNAME(a, b, c, d, e);                                          \
     }                                                                           \
     void CLASS::base_##CBNAME(bool a, double b, double c, int d, int e) {       \
         PCLASS::CBNAME(a, b, c, d, e);                                          \


@@ -633,22 +971,23 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

-#define DEC_PYCALLBACK__DC4DBL(CBNAME)                                      \
+#define DEC_PYCALLBACK__DC4DBL(CBNAME)                                          \

     void CBNAME(wxDC& a, double b, double c, double d, double e);               \
     void CBNAME(wxDC& a, double b, double c, double d, double e);               \

-    void base_##CBNAME(wxDC& a, double b, double c, double d, double e);
+    void base_##CBNAME(wxDC& a, double b, double c, double d, double e)

 
 
 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
 
 
 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);                 \
+        bool found;                                                             \
+        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);                                                     \
         }                                                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        else                                                                    \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \

             PCLASS::CBNAME(a, b, c, d, e);                                      \
             PCLASS::CBNAME(a, b, c, d, e);                                      \

-        wxPySaveThread(doSave);                                                 \

     }                                                                           \
     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e) {\
         PCLASS::CBNAME(a, b, c, d, e);                                          \
     }                                                                           \
     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e) {\
         PCLASS::CBNAME(a, b, c, d, e);                                          \


@@ -658,44 +997,46 @@ public:
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \

-    void base_##CBNAME(wxDC& a, bool b);
+    void base_##CBNAME(wxDC& a, bool b)

 
 
 
 

-#define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
-    void CLASS::CBNAME(wxDC& a, bool b) {                               \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);         \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
-            Py_DECREF(obj);                                             \
-        }                                                               \
-        else                                                            \
-            PCLASS::CBNAME(a, b);                                       \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
-        PCLASS::CBNAME(a, b);                                           \
+#define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                           \
+    void CLASS::CBNAME(wxDC& a, bool b) {                                       \
+        bool found;                                                             \
+        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);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a, b);                                               \
+    }                                                                           \
+    void CLASS::base_##CBNAME(wxDC& a, bool b) {                                \
+        PCLASS::CBNAME(a, b);                                                   \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \

-    void base_##CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);
+    void base_##CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f)

 
 
 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
                 int e, int f) {                                                 \
 
 
 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
                 int e, int f) {                                                 \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject(a, "wxPyControlPoint", 0);      \
+        bool found;                                                             \
+        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);                                                     \
         }                                                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        else                                                                    \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \

             PCLASS::CBNAME(a, b, c, d, e, f);                                   \
             PCLASS::CBNAME(a, b, c, d, e, f);                                   \

-        wxPySaveThread(doSave);                                                 \

     }                                                                           \
     void CLASS::base_##CBNAME(wxControlPoint* a, bool b, double c, double d,    \
                        int e, int f) {                                          \
     }                                                                           \
     void CLASS::base_##CBNAME(wxControlPoint* a, bool b, double c, double d,    \
                        int e, int f) {                                          \


@@ -706,20 +1047,21 @@ public:
 
 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \
 
 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \

-    void base_##CBNAME(wxControlPoint* a, double b, double c, int d, int e);
+    void base_##CBNAME(wxControlPoint* a, double b, double c, int d, int e)

 
 
 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
 
 
 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject(a, "wxPyControlPoint", 0);      \
+        bool found;                                                             \
+        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);                                                     \
         }                                                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        else                                                                    \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \

             PCLASS::CBNAME(a, b, c, d, e);                                      \
             PCLASS::CBNAME(a, b, c, d, e);                                      \

-        wxPySaveThread(doSave);                                                 \

     }                                                                           \
     void CLASS::base_##CBNAME(wxControlPoint* a, double b, double c,            \
                        int d, int e) {                                          \
     }                                                                           \
     void CLASS::base_##CBNAME(wxControlPoint* a, double b, double c,            \
                        int d, int e) {                                          \


@@ -730,37 +1072,39 @@ public:
 
 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
     void CBNAME(double a, double b, int c);             \
 
 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
     void CBNAME(double a, double b, int c);             \

-    void base_##CBNAME(double a, double b, int c);
-
-
-#define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                  \
-    void CLASS::CBNAME(double a, double b, int c) {                     \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));       \
-        else                                                            \
-            PCLASS::CBNAME(a, b, c);                                    \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void CLASS::base_##CBNAME(double a, double b, int c) {              \
-        PCLASS::CBNAME(a, b, c);                                        \
+    void base_##CBNAME(double a, double b, int c)
+
+
+#define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \
+    void CLASS::CBNAME(double a, double b, int c) {                             \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));      \
+        wxPyEndBlockThreads();                                             \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a, b, c);                                            \
+    }                                                                           \
+    void CLASS::base_##CBNAME(double a, double b, int c) {                      \
+        PCLASS::CBNAME(a, b, c);                                                \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
     void CBNAME(bool a, double b, double c, int d);             \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
     void CBNAME(bool a, double b, double c, int d);             \

-    void base_##CBNAME(bool a, double b, double c, int d);
+    void base_##CBNAME(bool a, double b, double c, int d)

 
 
 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
 
 
 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));       \
-        else                                                                    \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \

             PCLASS::CBNAME(a, b, c, d);                                         \
             PCLASS::CBNAME(a, b, c, d);                                         \

-        wxPySaveThread(doSave);                                                 \

     }                                                                           \
     void CLASS::base_##CBNAME(bool a, double b, double c, int d) {              \
         PCLASS::CBNAME(a, b, c, d);                                             \
     }                                                                           \
     void CLASS::base_##CBNAME(bool a, double b, double c, int d) {              \
         PCLASS::CBNAME(a, b, c, d);                                             \


@@ -771,38 +1115,44 @@ public:
 
 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
     void CBNAME(const wxString& a);                     \
 
 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
     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 doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));     \
-        else                                                            \
-            PCLASS::CBNAME(a);                                          \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void CLASS::base_##CBNAME(const wxString& a) {                      \
-        PCLASS::CBNAME(a);                                              \
+    void base_##CBNAME(const wxString& a)
+
+#define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                           \
+    void CLASS::CBNAME(const wxString& a)  {                                    \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* s = wx2PyString(a);                                       \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));            \
+            Py_DECREF(s);                                                       \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a);                                                  \
+    }                                                                           \
+    void CLASS::base_##CBNAME(const wxString& a) {                              \
+        PCLASS::CBNAME(a);                                                      \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
     bool CBNAME(const wxString& a);                     \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
     bool CBNAME(const wxString& a);                     \

-    bool base_##CBNAME(const wxString& a);
-
+    bool base_##CBNAME(const wxString& a)

 
 #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
     bool CLASS::CBNAME(const wxString& a)  {                                    \
 
 #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
     bool CLASS::CBNAME(const wxString& a)  {                                    \

-        bool rval;                                                              \
-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));      \
-        else                                                                    \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* s = wx2PyString(a);                                       \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
+            Py_DECREF(s);                                                       \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \

             rval = PCLASS::CBNAME(a);                                           \
             rval = PCLASS::CBNAME(a);                                           \

-        wxPySaveThread(doSave);                                                 \

         return rval;                                                            \
     }                                                                           \
     bool CLASS::base_##CBNAME(const wxString& a) {                              \
         return rval;                                                            \
     }                                                                           \
     bool CLASS::base_##CBNAME(const wxString& a) {                              \


@@ -812,59 +1162,91 @@ public:
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \

-    bool CBNAME(const wxString& a);
-                   \
+    bool CBNAME(const wxString& a)
+

 #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME)                  \
     bool CLASS::CBNAME(const wxString& a)  {                                    \
 #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME)                  \
     bool CLASS::CBNAME(const wxString& a)  {                                    \

-        bool rval;                                                              \
-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));      \
-        wxPySaveThread(doSave);                                                 \
+        bool rval=FALSE;                                                        \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* s = wx2PyString(a);                                       \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
+            Py_DECREF(s);                                                       \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \

         return rval;                                                            \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME)                               \
         return rval;                                                            \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME)                               \

-    wxString CBNAME(const wxString& a);                                         \
+    wxString CBNAME(const wxString& a)

 
 #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;                                                          \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \

             PyObject* ro;                                                       \
             PyObject* ro;                                                       \

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(s)", a.c_str()));     \
+            PyObject* s = wx2PyString(a);                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", s));    \
+            Py_DECREF(s);                                                       \

             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);                                                  \

             }                                                                   \
         }                                                                       \
             }                                                                   \
         }                                                                       \

-        wxPySaveThread(doSave);                                                 \
+        wxPyEndBlockThreads();                                                  \
+        return rval;                                                            \
+    }                                                                           \
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_STRING_STRING(CBNAME)                                    \
+    wxString CBNAME(const wxString& a);                                         \
+    wxString base_##CBNAME(const wxString& a)
+
+#define IMP_PYCALLBACK_STRING_STRING(CLASS, PCLASS, CBNAME)                     \
+    wxString CLASS::CBNAME(const wxString& a)  {                                \
+        wxString rval;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            PyObject* s = wx2PyString(a);                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", s));    \
+            Py_DECREF(s);                                                       \
+            if (ro) {                                                           \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        wxPyEndBlockThreads();                                                  \

         return rval;                                                            \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME)                            \
         return rval;                                                            \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME)                            \

-    wxString CBNAME(const wxString& a,int b);                                   \
+    wxString CBNAME(const wxString& a,int b)

 
 #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;                                                          \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \

             PyObject* ro;                                                       \
             PyObject* ro;                                                       \

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(si)", a.c_str(),b));  \
+            PyObject* s = wx2PyString(a);                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oi)",s,b));  \
+            Py_DECREF(s);                                                       \

             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);                                                  \

             }                                                                   \
         }                                                                       \
             }                                                                   \
         }                                                                       \

-        wxPySaveThread(doSave);                                                 \
+        wxPyEndBlockThreads();                                                  \

         return rval;                                                            \
     }                                                                           \
 
         return rval;                                                            \
     }                                                                           \
 


@@ -872,19 +1254,23 @@ public:
 
 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME)              \
     bool CBNAME(const wxString& a, const wxString& b);        \
 
 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME)              \
     bool CBNAME(const wxString& a, const wxString& b);        \

-    bool base_##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) {                  \
 
 #define IMP_PYCALLBACK_BOOL_STRINGSTRING(CLASS, PCLASS, CBNAME)                 \
     bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \

-        bool rval;                                                              \
-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ss)",                  \
-                                                       a.c_str(), b.c_str()));  \
-        else                                                                    \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* s1 = wx2PyString(a);                                      \
+            PyObject* s2 = wx2PyString(b);                                      \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",s1,s2)); \
+            Py_DECREF(s1);                                                      \
+            Py_DECREF(s2);                                                      \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \

             rval = PCLASS::CBNAME(a, b);                                        \
             rval = PCLASS::CBNAME(a, b);                                        \

-        wxPySaveThread(doSave);                                                 \

         return rval;                                                            \
     }                                                                           \
     bool CLASS::base_##CBNAME(const wxString& a, const wxString& b) {           \
         return rval;                                                            \
     }                                                                           \
     bool CLASS::base_##CBNAME(const wxString& a, const wxString& b) {           \


@@ -895,25 +1281,24 @@ public:
 
 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
     wxString CBNAME();                                  \
 
 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
     wxString CBNAME();                                  \

-    wxString base_##CBNAME();
-
+    wxString base_##CBNAME()

 
 #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
     wxString CLASS::CBNAME() {                                                  \
         wxString rval;                                                          \
 
 #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
     wxString CLASS::CBNAME() {                                                  \
         wxString rval;                                                          \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

             PyObject* ro;                                                       \
             PyObject* ro;                                                       \

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \

             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);                                                  \

             }                                                                   \
         }                                                                       \
             }                                                                   \
         }                                                                       \

-        else                                                                    \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \

             rval = PCLASS::CBNAME();                                            \
             rval = PCLASS::CBNAME();                                            \

-        wxPySaveThread(doSave);                                                 \

         return rval;                                                            \
     }                                                                           \
     wxString CLASS::base_##CBNAME() {                                           \
         return rval;                                                            \
     }                                                                           \
     wxString CLASS::base_##CBNAME() {                                           \


@@ -922,81 +1307,193 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

-#define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
-    wxString CBNAME();
+#define DEC_PYCALLBACK_STRING__const(CBNAME)                  \
+    wxString CBNAME() const;                                  \
+    wxString base_##CBNAME() const;
+
+#define IMP_PYCALLBACK_STRING__const(CLASS, PCLASS, CBNAME)                     \
+    wxString CLASS::CBNAME() const {                                            \
+        wxString rval;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                            \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME();                                            \
+        return rval;                                                            \
+    }                                                                           \
+    wxString CLASS::base_##CBNAME() const {                                     \
+        return PCLASS::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;                                                          \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+        wxPyBeginBlockThreads();                            \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \

             PyObject* ro;                                                       \
             PyObject* ro;                                                       \

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \

             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);                                                  \

             }                                                                   \
         }                                                                       \
             }                                                                   \
         }                                                                       \

-        wxPySaveThread(doSave);                                                 \
+        wxPyEndBlockThreads();                                                  \
+        return rval;                                                            \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_STRING__constpure(CBNAME)             \
+    wxString CBNAME() const;
+
+#define IMP_PYCALLBACK_STRING__constpure(CLASS, PCLASS, CBNAME)                 \
+    wxString CLASS::CBNAME() const {                                            \
+        wxString rval;                                                          \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \

         return rval;                                                            \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \
         return rval;                                                            \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \

-    bool CBNAME(const wxHtmlTag& a);                          \
+    bool CBNAME(const wxHtmlTag& a)

 
 
 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
 
 
 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \

-        bool rval = FALSE;                                                      \
-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject((void*)&a,"wxHtmlTag", 0);      \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));            \
+        bool rval=FALSE;                                                        \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT("wxHtmlTag"), 0);     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \

             Py_DECREF(obj);                                                     \
         }                                                                       \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPySaveThread(doSave);                                                 \
+        wxPyEndBlockThreads();                                                  \

         return rval;                                                            \
     }
 
         return rval;                                                            \
     }
 

+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK__CELLINTINT(CBNAME)                                      \
+    void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);                        \
+    void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y)
+
+#define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
+    void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)cell, wxT("wxHtmlCell"), 0);  \
+            wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y));  \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(cell, x, y);                                         \
+    }                                                                           \
+    void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {         \
+        PCLASS::CBNAME(cell, x, y);                                             \
+    }
+
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK__CELLINTINTME(CBNAME)                                    \
+    void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e); \
+    void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e)
+
+#define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
+    void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)cell, wxT("wxHtmlCell"), 0);  \
+            PyObject* o2  = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0);  \
+            wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OiiO)",obj,x,y,o2));  \
+            Py_DECREF(obj);                                                     \
+            Py_DECREF(o2);                                                      \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(cell, x, y, e);                                      \
+    }                                                                           \
+    void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {         \
+        PCLASS::CBNAME(cell, x, y, e);                                          \
+    }
+
+
+

 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK___pure(CBNAME)                         \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK___pure(CBNAME)                         \

-    void CBNAME();                                            \
+    void CBNAME()

 
 
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
     void CLASS::CBNAME() {                                                      \
 
 
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
     void CLASS::CBNAME() {                                                      \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                         \
-        wxPySaveThread(doSave);                                                 \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
+        wxPyEndBlockThreads();                                                  \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_wxSize__pure(CBNAME)                         \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_wxSize__pure(CBNAME)                         \

-    wxSize CBNAME();                                                \
+    wxSize CBNAME()

 
 
 #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);                                                       \

-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \

             PyObject* ro;                                                       \
             wxSize*   ptr;                                                      \
             PyObject* ro;                                                       \
             wxSize*   ptr;                                                      \

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \

             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);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPySaveThread(doSave);                                                 \
+        wxPyEndBlockThreads();                                                  \

         return rval;                                                            \
     }
 
         return rval;                                                            \
     }
 


@@ -1004,92 +1501,172 @@ public:
 
 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME)                      \
     bool CBNAME(wxWindow* a);                                  \
 
 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME)                      \
     bool CBNAME(wxWindow* a);                                  \

-    bool base_##CBNAME(wxWindow* a);
+    bool base_##CBNAME(wxWindow* a)

 
 
 
 

-#define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                \
-    bool CLASS::CBNAME(wxWindow* a) {                                   \
-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)a,"wxWindow", 0);\
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));    \
-            Py_DECREF(obj);                                             \
-        }                                                               \
-        else                                                            \
-            rval = PCLASS::CBNAME(a);                                   \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    bool CLASS::base_##CBNAME(wxWindow* a) {                            \
-        return PCLASS::CBNAME(a);                                       \
+#define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                        \
+    bool CLASS::CBNAME(wxWindow* a) {                                           \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        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);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }                                                                           \
+    bool CLASS::base_##CBNAME(wxWindow* a) {                                    \
+        return PCLASS::CBNAME(a);                                               \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BOOL_WXWINDC(CBNAME)                             \
+    bool CBNAME(wxWindow* a, wxDC& b);                                  \
+    bool base_##CBNAME(wxWindow* a, wxDC& b)
+
+
+#define IMP_PYCALLBACK_BOOL_WXWINDC(CLASS, PCLASS, CBNAME)                        \
+    bool CLASS::CBNAME(wxWindow* a, wxDC& b) {                                  \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* win = wxPyMake_wxObject(a);                               \
+            PyObject* dc  = wxPyMake_wxObject(&b);                              \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));\
+            Py_DECREF(win);                                                     \
+            Py_DECREF(dc);                                                      \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a, b);                                        \
+        return rval;                                                            \
+    }                                                                           \
+    bool CLASS::base_##CBNAME(wxWindow* a, wxDC& b) {                           \
+        return PCLASS::CBNAME(a, b);                                            \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_VOID_WXWINBASE(CBNAME)                      \
+    void CBNAME(wxWindowBase* a);                                  \
+    void base_##CBNAME(wxWindowBase* a)
+
+
+#define IMP_PYCALLBACK_VOID_WXWINBASE(CLASS, PCLASS, CBNAME)                    \
+    void CLASS::CBNAME(wxWindowBase* a) {                                       \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyMake_wxObject(a);                               \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a);                                                  \
+    }                                                                           \
+    void CLASS::base_##CBNAME(wxWindowBase* a) {                                \
+        PCLASS::CBNAME(a);                                                      \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_(CBNAME)                      \
     bool CBNAME();                                        \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_(CBNAME)                      \
     bool CBNAME();                                        \

-    bool base_##CBNAME();
-
-
-#define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                     \
-    bool CLASS::CBNAME() {                                              \
-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));          \
-        else                                                            \
-            rval = PCLASS::CBNAME();                                    \
-        wxPySaveThread(doSave);                                         \
-        return rval;                                                    \
-    }                                                                   \
-    bool CLASS::base_##CBNAME() {                                       \
-        return PCLASS::CBNAME();                                        \
+    bool base_##CBNAME()
+
+
+#define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                             \
+    bool CLASS::CBNAME() {                                                      \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME();                                            \
+        return rval;                                                            \
+    }                                                                           \
+    bool CLASS::base_##CBNAME() {                                               \
+        return PCLASS::CBNAME();                                                \

     }
 
 //---------------------------------------------------------------------------
 
     }
 
 //---------------------------------------------------------------------------
 

-#define DEC_PYCALLBACK_DR_2WXCDR(CBNAME)                 \
-    wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);    \
-    wxDragResult base_##CBNAME(wxCoord x, wxCoord y, wxDragResult def);
+#define DEC_PYCALLBACK_BOOL_const(CBNAME)                       \
+    bool CBNAME() const;                                        \
+    bool base_##CBNAME() const

 
 
 
 

-#define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                 \
-    wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
-        bool doSave = wxPyRestoreThread();                              \
-        int rval;                                                       \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+#define IMP_PYCALLBACK_BOOL_const(CLASS, PCLASS, CBNAME)                        \
+    bool CLASS::CBNAME() const {                                                \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME();                                            \
+        return rval;                                                            \
+    }                                                                           \
+    bool CLASS::base_##CBNAME() const {                                         \
+        return PCLASS::CBNAME();                                                \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_DR_2WXCDR(CBNAME)                                \
+    wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);        \
+    wxDragResult base_##CBNAME(wxCoord x, wxCoord y, wxDragResult def)
+
+
+#define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                         \
+    wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {          \
+        int rval=0;                                                             \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \

             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\

-        else                                                            \
-            rval = PCLASS::CBNAME(a, b, c);                             \
-        wxPySaveThread(doSave);                                         \
-        return (wxDragResult)rval;                                      \
-    }                                                                   \
-    wxDragResult CLASS::base_##CBNAME(wxCoord a, wxCoord b, wxDragResult c) { \
-        return PCLASS::CBNAME(a, b, c);                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a, b, c);                                     \
+        return (wxDragResult)rval;                                              \
+    }                                                                           \
+    wxDragResult CLASS::base_##CBNAME(wxCoord a, wxCoord b, wxDragResult c) {   \
+        return PCLASS::CBNAME(a, b, c);                                         \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \

-    wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location);       \
+    wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location)

 
 #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) {        \

-        bool doSave = wxPyRestoreThread();                              \
+        wxPyBeginBlockThreads();                                        \

         wxFSFile* rval=0;                                               \
         wxFSFile* rval=0;                                               \

-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \

             PyObject* ro;                                               \
             PyObject* ro;                                               \

-            PyObject* obj = wxPyConstructObject(&a, "wxFileSystem", 0); \
-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Os)",         \
-                                          obj, b.c_str()));             \
+            PyObject* obj = wxPyMake_wxObject(&a);                      \
+            PyObject* s = wx2PyString(b);                               \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)",\
+                                         obj, s));                      \

             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);                                             \

+            Py_DECREF(s);                                               \

         }                                                               \
         }                                                               \

-        wxPySaveThread(doSave);                                         \
+        wxPyEndBlockThreads();                                          \

         return rval;                                                    \
     };
 
         return rval;                                                    \
     };
 


@@ -1097,18 +1674,19 @@ public:
 
 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
     bool CBNAME(wxDragResult a);                        \
 
 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
     bool CBNAME(wxDragResult a);                        \

-    bool base_##CBNAME(wxDragResult a);
+    bool base_##CBNAME(wxDragResult a)

 
 
 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \
     bool CLASS::CBNAME(wxDragResult a) {                                \
 
 
 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \
     bool CLASS::CBNAME(wxDragResult a) {                                \

-        bool doSave = wxPyRestoreThread();                              \
-        bool rval;                                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));      \
-        else                                                            \
+        bool rval=FALSE;                                                \
+        bool found;                                                     \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));\
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \

             rval = PCLASS::CBNAME(a);                                   \
             rval = PCLASS::CBNAME(a);                                   \

-        wxPySaveThread(doSave);                                         \

         return rval;                                                    \
     }                                                                   \
     bool CLASS::base_##CBNAME(wxDragResult a) {                         \
         return rval;                                                    \
     }                                                                   \
     bool CLASS::base_##CBNAME(wxDragResult a) {                         \


@@ -1118,32 +1696,34 @@ public:
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME)   \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME)   \

-    wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);
+    wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def)

 
 
 #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) {  \

-        bool doSave = wxPyRestoreThread();                              \
-        int rval;                                                       \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+        wxPyBeginBlockThreads();                                        \
+        int rval=0;                                                     \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \

             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\

-        wxPySaveThread(doSave);                                         \
+        wxPyEndBlockThreads();                                          \

         return (wxDragResult)rval;                                      \
     }                                                                   \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \
         return (wxDragResult)rval;                                      \
     }                                                                   \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \

-    bool CBNAME(int a, int b, const wxString& c);
-
+    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) {               \
 
 #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \

-        bool rval;                                                      \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
-        wxPySaveThread(doSave);                                         \
+        bool rval=FALSE;                                                \
+        wxPyBeginBlockThreads();                                        \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \
+            PyObject* s = wx2PyString(c);                               \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
+            Py_DECREF(s);                                               \
+        }                                                               \
+        wxPyEndBlockThreads();                                          \

         return rval;                                                    \
     }                                                                   \
 
         return rval;                                                    \
     }                                                                   \
 


@@ -1151,18 +1731,19 @@ public:
 
 #define DEC_PYCALLBACK_SIZET_(CBNAME)                  \
     size_t CBNAME();                                   \
 
 #define DEC_PYCALLBACK_SIZET_(CBNAME)                  \
     size_t CBNAME();                                   \

-    size_t base_##CBNAME();
+    size_t base_##CBNAME()

 
 
 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
     size_t CLASS::CBNAME() {                                                    \
 
 
 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
     size_t CLASS::CBNAME() {                                                    \

-        size_t rval;                                                            \
-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                  \
-        else                                                                    \
+        size_t rval=0;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \

             rval = PCLASS::CBNAME();                                            \
             rval = PCLASS::CBNAME();                                            \

-        wxPySaveThread(doSave);                                                 \

         return rval;                                                            \
     }                                                                           \
     size_t CLASS::base_##CBNAME() {                                             \
         return rval;                                                            \
     }                                                                           \
     size_t CLASS::base_##CBNAME() {                                             \


@@ -1171,28 +1752,29 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

-#define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME)                  \
-    wxDataFormat  CBNAME();                                        \
-    wxDataFormat  base_##CBNAME();
+#define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME)                                    \
+    wxDataFormat  CBNAME(size_t a);                                             \
+    wxDataFormat  base_##CBNAME(size_t a)

 
 
 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
 
 
 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
     wxDataFormat CLASS::CBNAME(size_t a) {                                      \

-        wxDataFormat rval;                                                      \
-        bool doSave = wxPyRestoreThread();                                      \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+        wxDataFormat rval=0;                                                    \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

             PyObject* ro;                                                       \
             wxDataFormat* ptr;                                                  \
             PyObject* ro;                                                       \
             wxDataFormat* ptr;                                                  \

-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));             \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \

             if (ro) {                                                           \
                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxDataFormat_p"))     \
                     rval = *ptr;                                                \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
             if (ro) {                                                           \
                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxDataFormat_p"))     \
                     rval = *ptr;                                                \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        else                                                                    \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \

             rval = PCLASS::CBNAME(a);                                           \
             rval = PCLASS::CBNAME(a);                                           \

-        wxPySaveThread(doSave);                                                 \

         return rval;                                                            \
     }                                                                           \
     wxDataFormat  CLASS::base_##CBNAME(size_t a) {                              \
         return rval;                                                            \
     }                                                                           \
     wxDataFormat  CLASS::base_##CBNAME(size_t a) {                              \


@@ -1203,23 +1785,24 @@ public:
 
 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
     void CBNAME(const Type& a);                         \
 
 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
     void CBNAME(const Type& a);                         \

-    void base_##CBNAME(const Type& a);
+    void base_##CBNAME(const Type& a)

 
 
 
 

-#define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)           \
-    void CLASS::CBNAME(const Type& a) {                                 \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));           \
-            Py_DECREF(obj);                                             \
-        }                                                               \
-        else                                                            \
-            PCLASS::CBNAME(a);                                          \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void CLASS::base_##CBNAME(const Type& a) {                          \
-        PCLASS::CBNAME(a);                                              \
+#define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
+    void CLASS::CBNAME(const Type& a) {                                         \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a);                                                  \
+    }                                                                           \
+    void CLASS::base_##CBNAME(const Type& a) {                                  \
+        PCLASS::CBNAME(a);                                                      \

     }
 
 
     }
 
 


@@ -1227,54 +1810,455 @@ public:
 
 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
     void CBNAME(Type& a);                          \
 
 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
     void CBNAME(Type& a);                          \

-    void base_##CBNAME(Type& a);
+    void base_##CBNAME(Type& a)

 
 
 
 

-#define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                \
-    void CLASS::CBNAME(Type& a) {                                       \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
-            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));           \
-            Py_DECREF(obj);                                             \
-        }                                                               \
-        else                                                            \
-            PCLASS::CBNAME(a);                                          \
-        wxPySaveThread(doSave);                                         \
-    }                                                                   \
-    void CLASS::base_##CBNAME(Type& a) {                                \
-        PCLASS::CBNAME(a);                                              \
+#define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
+    void CLASS::CBNAME(Type& a) {                                               \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a);                                                  \
+    }                                                                           \
+    void CLASS::base_##CBNAME(Type& a) {                                        \
+        PCLASS::CBNAME(a);                                                      \

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
     bool CBNAME(Type& a);                               \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
     bool CBNAME(Type& a);                               \

-    bool base_##CBNAME(Type& a);
+    bool base_##CBNAME(Type& a)

 
 
 
 

-#define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)            \
-    bool CLASS::CBNAME(Type& a) {                                       \
-        bool rv;                                                        \
-        bool doSave = wxPyRestoreThread();                              \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
-            rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));      \
-            Py_DECREF(obj);                                             \
-        }                                                               \
-        else                                                            \
-            rv = PCLASS::CBNAME(a);                                     \
-        wxPySaveThread(doSave);                                         \
-        return rv;                                                      \
-    }                                                                   \
-    bool CLASS::base_##CBNAME(Type& a) {                                \
-        return PCLASS::CBNAME(a);                                       \
+#define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
+    bool CLASS::CBNAME(Type& a) {                                               \
+        bool rv=FALSE;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rv = PCLASS::CBNAME(a);                                             \
+        return rv;                                                              \
+    }                                                                           \
+    bool CLASS::base_##CBNAME(Type& a) {                                        \
+        return PCLASS::CBNAME(a);                                               \

     }
 
 //---------------------------------------------------------------------------
 
     }
 
 //---------------------------------------------------------------------------
 

-#endif
+#define DEC_PYCALLBACK_bool_anypure(CBNAME, Type)                               \
+    bool CBNAME(Type& a)
+
+
+#define IMP_PYCALLBACK_bool_anypure(CLASS, PCLASS, CBNAME, Type)                \
+    bool CLASS::CBNAME(Type& a) {                                               \
+        bool rv=FALSE;                                                          \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }                                                                           \

 
 

+//---------------------------------------------------------------------------

 
 

+#define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME)                                  \
+    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;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \
+            if (ro) {                                                           \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a,b);                                         \
+        return rval;                                                            \
+    }                                                                           \
+    wxString CLASS::base_##CBNAME(long a, long b) const {                       \
+        return PCLASS::CBNAME(a,b);                                             \
+    }

 
 

+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_INT_LONG(CBNAME)                                         \
+    int CBNAME(long a) const;                                                   \
+    int base_##CBNAME(long a) const
+
+
+#define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME)                          \
+    int CLASS::CBNAME(long a) const {                                           \
+        int rval=-1;                                                            \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
+            if (ro) {                                                           \
+                rval = PyInt_AsLong(ro);                                        \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }                                                                           \
+    int CLASS::base_##CBNAME(long a) const {                                    \
+        return PCLASS::CBNAME(a);                                               \
+    }
+
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_LISTATTR_LONG(CBNAME)                                    \
+    wxListItemAttr*  CBNAME(long a) const;                                      \
+    wxListItemAttr*  base_##CBNAME(long a) const
+
+
+#define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME)                     \
+    wxListItemAttr *CLASS::CBNAME(long a) const {                               \
+        wxListItemAttr *rval = NULL;                                            \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            wxListItemAttr* ptr;                                                \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \
+            if (ro) {                                                           \
+                if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxListItemAttr_p"))   \
+                    rval = ptr;                                                 \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }                                                                           \
+    wxListItemAttr *CLASS::base_##CBNAME(long a) const {                        \
+        return PCLASS::CBNAME(a);                                               \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BOOL_ME(CBNAME)                                          \
+    bool CBNAME(wxMouseEvent& e);                                               \
+    bool base_##CBNAME(wxMouseEvent& 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, wxT("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);                                               \
+    }
+
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_WIZPG__pure(CBNAME)                                      \
+    wxWizardPage* CBNAME() const
+
+#define IMP_PYCALLBACK_WIZPG__pure(CLASS, PCLASS, CBNAME)                       \
+    wxWizardPage* CLASS::CBNAME() const {                                       \
+        wxWizardPage* rv = NULL;                                                \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                SWIG_GetPtrObj(ro, (void **)&rv, "_wxWizardPage_p");            \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BITMAP__pure(CBNAME)                                     \
+    wxBitmap CBNAME() const
+
+#define IMP_PYCALLBACK_BITMAP__pure(CLASS, PCLASS, CBNAME)                      \
+    wxBitmap CLASS::CBNAME() const {                                            \
+        wxBitmap rv;                                                            \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* ro;                                                       \
+            wxBitmap* ptr;                                                      \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxBitmap_p"))         \
+                    rv = *ptr;                                                  \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_OBJECT__pure(CBNAME)                                     \
+    wxObject* CBNAME()
+
+#define IMP_PYCALLBACK_OBJECT__pure(CLASS, PCLASS, CBNAME)                      \
+    wxObject* CLASS::CBNAME() {                                                 \
+        wxObject* rv = NULL;                                                    \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                SWIG_GetPtrObj(ro, (void **)&rv, "_wxObject_p");                \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_OBJECT_STRING_pure(CBNAME)                               \
+    wxObject* CBNAME(const wxString& a)
+
+#define IMP_PYCALLBACK_OBJECT_STRING_pure(CLASS, PCLASS, CBNAME)                \
+    wxObject* CLASS::CBNAME(const wxString& a) {                                \
+        wxObject* rv = NULL;                                                    \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* so = wx2PyString(a);                                      \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", so));   \
+            if (ro) {                                                           \
+                SWIG_GetPtrObj(ro, (void **)&rv, "_wxObject_p");                \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+            Py_DECREF(so);                                                      \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BOOL_NODE_pure(CBNAME)                                   \
+    bool CBNAME(wxXmlNode* a)
+
+
+#define IMP_PYCALLBACK_BOOL_NODE_pure(CLASS, PCLASS, CBNAME)                    \
+    bool CLASS::CBNAME(wxXmlNode* a) {                                          \
+        bool rv=FALSE;                                                          \
+        wxPyBeginBlockThreads();                                                \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* obj = wxPyConstructObject((void*)a, wxT("wxXmlNode"), 0);      \
+            rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }                                                                           \
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_COORD_SIZET_constpure(CBNAME)                            \
+    wxCoord CBNAME(size_t a) const
+
+
+#define IMP_PYCALLBACK_COORD_SIZET_constpure(CLASS, PCLASS, CBNAME)             \
+    wxCoord CLASS::CBNAME(size_t a) const {                                     \
+        wxCoord rval=0;                                                         \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rval;                                                            \
+    }                                                                           \
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_VOID_SIZETSIZET_const(CBNAME)                            \
+    void CBNAME(size_t a, size_t b) const;                                      \
+    void base_##CBNAME(size_t a, size_t b) const
+
+
+#define IMP_PYCALLBACK_VOID_SIZETSIZET_const(CLASS, PCLASS, CBNAME)             \
+    void CLASS::CBNAME(size_t a, size_t b) const {                              \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));          \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,b);                                                \
+    }                                                                           \
+    void CLASS::base_##CBNAME(size_t a, size_t b) const {                       \
+        PCLASS::CBNAME(a,b);                                                    \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_COORD_const(CBNAME)                       \
+    wxCoord CBNAME() const;                                      \
+    wxCoord base_##CBNAME() const
+
+
+#define IMP_PYCALLBACK_COORD_const(CLASS, PCLASS, CBNAME)                       \
+    wxCoord CLASS::CBNAME() const {                                             \
+        wxCoord rval=0;                                                         \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME();                                            \
+        return rval;                                                            \
+    }                                                                           \
+    wxCoord CLASS::base_##CBNAME() const {                                      \
+        return PCLASS::CBNAME();                                                \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK__DCRECTSIZET_constpure(CBNAME)                           \
+    void CBNAME(wxDC& a, const wxRect& b, size_t c) const;
+
+
+#define IMP_PYCALLBACK__DCRECTSIZET_constpure(CLASS, PCLASS, CBNAME)            \
+    void CLASS::CBNAME(wxDC& a, const wxRect& b, size_t c) const {              \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyMake_wxObject(&a);                              \
+            PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+    }                                                                           \
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK__DCRECTSIZET_const(CBNAME)                               \
+    void CBNAME(wxDC& a, const wxRect& b, size_t c) const;                      \
+    void base_##CBNAME(wxDC& a, const wxRect& b, size_t c) const
+
+
+#define IMP_PYCALLBACK__DCRECTSIZET_const(CLASS, PCLASS, CBNAME)                \
+    void CLASS::CBNAME(wxDC& a, const wxRect& b, size_t c) const {              \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyMake_wxObject(&a);                              \
+            PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a,b,c);                                              \
+    }                                                                           \
+    void CLASS::base_##CBNAME(wxDC& a, const wxRect& b, size_t c) const {       \
+        PCLASS::CBNAME(a,b,c);                                                  \
+    }
+
+//---------------------------------------------------------------------------
+
+
+#define DEC_PYCALLBACK_STRING_SIZET(CBNAME)                                     \
+    wxString CBNAME(size_t a) const;                                            \
+    wxString base_##CBNAME(size_t a) const
+
+#define IMP_PYCALLBACK_STRING_SIZET(CLASS, PCLASS, CBNAME)                      \
+    wxString CLASS::CBNAME(size_t a) const {                                    \
+        wxString rval;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
+            if (ro) {                                                           \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }                                                                           \
+    wxString CLASS::base_##CBNAME(size_t a) const {                             \
+        return PCLASS::CBNAME(a);                                               \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_STRING_SIZET_pure(CBNAME)                                \
+    wxString CBNAME(size_t a) const
+
+#define IMP_PYCALLBACK_STRING_SIZET_pure(CLASS, PCLASS, CBNAME)                 \
+    wxString CLASS::CBNAME(size_t a) const {                                    \
+        wxString rval;                                                          \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
+            if (ro) {                                                           \
+                rval = Py2wxString(ro);                                         \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rval;                                                            \
+    }                                                                           \
+
+//---------------------------------------------------------------------------
+
+#endif