Add FindLength()

[wxWidgets.git] / wxPython / include / wx / wxPython / wxPython_int.h

diff --git a/wxPython/include/wx/wxPython/wxPython_int.h b/wxPython/include/wx/wxPython/wxPython_int.h
index ed07d2ee978f7da3d6b23eaa6bbd159b6c4e2ca0..3cfbdbbf74db1b7ef77e8ca0da3ea148e31841f8 100644 (file)
--- a/wxPython/include/wx/wxPython/wxPython_int.h
+++ b/wxPython/include/wx/wxPython/wxPython_int.h
@@ -20,6 +20,7 @@
 
 #include <wx/busyinfo.h>
 #include <wx/caret.h>
 
 #include <wx/busyinfo.h>
 #include <wx/caret.h>

+#include <wx/choicebk.h>

 #include <wx/clipbrd.h>
 #include <wx/colordlg.h>
 #include <wx/config.h>
 #include <wx/clipbrd.h>
 #include <wx/colordlg.h>
 #include <wx/config.h>


@@ -28,6 +29,7 @@
 #include <wx/dcps.h>
 #include <wx/dirctrl.h>
 #include <wx/dirdlg.h>
 #include <wx/dcps.h>
 #include <wx/dirctrl.h>
 #include <wx/dirdlg.h>

+#include <wx/numdlg.h>

 #include <wx/dnd.h>
 #include <wx/docview.h>
 #include <wx/encconv.h>
 #include <wx/dnd.h>
 #include <wx/docview.h>
 #include <wx/encconv.h>


@@ -63,9 +65,19 @@
 #include <wx/taskbar.h>
 #include <wx/tglbtn.h>
 #include <wx/tipwin.h>
 #include <wx/taskbar.h>
 #include <wx/tglbtn.h>
 #include <wx/tipwin.h>

+#include <wx/toolbook.h>

 #include <wx/tooltip.h>
 #include <wx/tooltip.h>

+#include <wx/treebook.h>

 #include <wx/vlbox.h>
 #include <wx/vscroll.h>
 #include <wx/vlbox.h>
 #include <wx/vscroll.h>

+#include <wx/dateevt.h>
+#include <wx/datectrl.h>
+#include <wx/power.h>
+#include <wx/hyperlink.h>
+#include <wx/pickerbase.h>
+#include <wx/clrpicker.h>
+#include <wx/filepicker.h>
+#include <wx/fontpicker.h>    

 
 
 #ifdef _MSC_VER
 
 
 #ifdef _MSC_VER


@@ -79,11 +91,33 @@
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

-typedef unsigned char byte;
+#ifndef wxHAS_POWER_EVENTS
+class wxPowerEvent : public wxEvent
+{
+public:
+    wxPowerEvent(wxEventType evtType) : wxEvent(wxID_NONE, evtType) {}
+    void Veto() {}
+    bool IsVetoed() const { return false; }
+    virtual wxEvent *Clone() const { return new wxPowerEvent(*this); }
+};
+#endif
+
+//---------------------------------------------------------------------------
+typedef unsigned char  byte;
+typedef unsigned char* buffer;
+

 typedef wxPoint2DDouble wxPoint2D;    
 typedef wxPoint2DDouble wxPoint2D;    

+typedef wxRect2DDouble  wxRect2D;
+
+#ifndef SWIG_TYPE_TABLE
+#define SWIG_TYPE_TABLE wxPython_type_table
+#endif

 
 

-const bool True = true;
-const bool False = false;
+#ifdef __WXGTK__
+#define wxDEFAULT_STATUSBAR_STYLE wxST_SIZEGRIP|wxFULL_REPAINT_ON_RESIZE
+#else
+#define wxDEFAULT_STATUSBAR_STYLE wxST_SIZEGRIP
+#endif

 
 
 #ifndef wxPyUSE_EXPORTED_API
 
 
 #ifndef wxPyUSE_EXPORTED_API


@@ -91,7 +125,9 @@ const bool False = false;
 void      __wxPyPreStart(PyObject*);
 void      __wxPyCleanup();
 PyObject* __wxPySetDictionary(PyObject*, PyObject* args);
 void      __wxPyPreStart(PyObject*);
 void      __wxPyCleanup();
 PyObject* __wxPySetDictionary(PyObject*, PyObject* args);

-PyObject* __wxPyFixStockObjects(PyObject*, PyObject* args);
+
+void        wxSetDefaultPyEncoding(const char* encoding);
+const char* wxGetDefaultPyEncoding();

 
 
 void wxPyEventThunker(wxObject*, wxEvent& event);
 
 
 void wxPyEventThunker(wxObject*, wxEvent& event);


@@ -109,8 +145,8 @@ PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* classname);
 PyObject* wx2PyString(const wxString& src);
 wxString  Py2wxString(PyObject* source);
 
 PyObject* wx2PyString(const wxString& src);
 wxString  Py2wxString(PyObject* source);
 

-PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler=True);
-PyObject* wxPyMake_wxSizer(wxSizer* source);
+PyObject* wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHandler=true);
+PyObject* wxPyMake_wxSizer(wxSizer* source, bool setThisOwn);

 void      wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
 
 PyObject* wxPy_ConvertList(wxListBase* list);
 void      wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
 
 PyObject* wxPy_ConvertList(wxListBase* list);


@@ -132,6 +168,35 @@ bool wxPySwigInstance_Check(PyObject* obj);
 #undef WXP_WITH_THREAD
 #endif
 
 #undef WXP_WITH_THREAD
 #endif
 

+
+// In Python 2.3 and later there are the PyGILState_* APIs that we can use for
+// blocking threads when calling back into Python. Using them instead of my
+// home-grown hacks greatly simplifies wxPyBeginBlockThreads and
+// wxPyEndBlockThreads.
+//
+// Unfortunatly there is a bug somewhere when using these new APIs on Python
+// 2.3.  It manifests in Boa Constructor's debugger where it is unable to stop
+// at breakpoints located in event handlers.  I think that the cause may be
+// something like the original PyThreadState for the main thread is not being
+// restored for the callbacks, but I can't see where that could be
+// happening...  So we'll only activate this new change for Python 2.4+  :-(
+
+#if PY_VERSION_HEX < 0x02040000
+#define wxPyUSE_GIL_STATE 0
+typedef bool wxPyBlock_t;
+#else
+#define wxPyUSE_GIL_STATE 1
+typedef PyGILState_STATE wxPyBlock_t;
+#endif
+
+
+// Python 2.5 changes the type of some API parameter and return types.  Using
+// this typedef for versions < 2.5 will help with the transition...
+#if PY_VERSION_HEX < 0x02050000
+typedef int Py_ssize_t;
+#endif
+
+

 #ifndef wxPyUSE_EXPORTED_API
 
 // For Python --> C++
 #ifndef wxPyUSE_EXPORTED_API
 
 // For Python --> C++


@@ -139,13 +204,25 @@ PyThreadState* wxPyBeginAllowThreads();
 void           wxPyEndAllowThreads(PyThreadState* state);
 
 // For C++ --> Python
 void           wxPyEndAllowThreads(PyThreadState* state);
 
 // For C++ --> Python

-void wxPyBeginBlockThreads();
-void wxPyEndBlockThreads();
+wxPyBlock_t wxPyBeginBlockThreads();
+void wxPyEndBlockThreads(wxPyBlock_t blocked);

 
 #endif // wxPyUSE_EXPORTED_API
 
 
 #endif // wxPyUSE_EXPORTED_API
 

-#define wxPyBLOCK_THREADS(stmt) { wxPyBeginBlockThreads(); stmt; wxPyEndBlockThreads(); }
-#define wxPyRaiseNotImplemented() wxPyBLOCK_THREADS(PyErr_SetNone(PyExc_NotImplementedError))
+
+// A macro that will help to execute simple statments wrapped in
+// StartBlock/EndBlockThreads calls
+#define wxPyBLOCK_THREADS(stmt) \
+    { wxPyBlock_t blocked = wxPyBeginBlockThreads(); stmt; wxPyEndBlockThreads(blocked); }
+
+// Raise the NotImplementedError exception  (blocking threads)
+#define wxPyRaiseNotImplemented() \
+    wxPyBLOCK_THREADS(PyErr_SetNone(PyExc_NotImplementedError))
+
+// Raise any exception with a string value  (blocking threads)
+#define wxPyErr_SetString(err, str) \
+    wxPyBLOCK_THREADS(PyErr_SetString(err, str))
+

 
 //---------------------------------------------------------------------------
 // These are helpers used by the typemaps
 
 //---------------------------------------------------------------------------
 // These are helpers used by the typemaps


@@ -159,6 +236,7 @@ int* int_LIST_helper(PyObject* source);
 long* long_LIST_helper(PyObject* source);
 char** string_LIST_helper(PyObject* source);
 wxPoint* wxPoint_LIST_helper(PyObject* source, int* npoints);
 long* long_LIST_helper(PyObject* source);
 char** string_LIST_helper(PyObject* source);
 wxPoint* wxPoint_LIST_helper(PyObject* source, int* npoints);

+wxPoint2D* wxPoint2D_LIST_helper(PyObject* source, size_t* 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);


@@ -170,53 +248,23 @@ bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
 bool wxRect_helper(PyObject* source, wxRect** obj);
 bool wxColour_helper(PyObject* source, wxColour** obj);
 bool wxPoint2D_helper(PyObject* source, wxPoint2D** obj);
 bool wxRect_helper(PyObject* source, wxRect** obj);
 bool wxColour_helper(PyObject* source, wxColour** obj);
 bool wxPoint2D_helper(PyObject* source, wxPoint2D** obj);

+bool wxRect2D_helper(PyObject* source, wxRect2D** obj);

 
 
 bool wxPySimple_typecheck(PyObject* source, const wxChar* classname, int seqLen);
 bool wxColour_typecheck(PyObject* source);
 
 
 
 
 bool wxPySimple_typecheck(PyObject* source, const wxChar* classname, int seqLen);
 bool wxColour_typecheck(PyObject* source);
 
 

-template<class T>
-bool wxPyTwoIntItem_helper(PyObject* source, T** obj, const wxChar* name)
-{
-    // If source is an object instance then it may already be the right type
-    if (wxPySwigInstance_Check(source)) {
-        T* ptr;
-        if (! wxPyConvertSwigPtr(source, (void **)&ptr, name))
-            goto error;
-        *obj = ptr;
-        return True;
-    }
-    // otherwise a 2-tuple of integers is expected
-    else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
-        PyObject* o1 = PySequence_GetItem(source, 0);
-        PyObject* o2 = PySequence_GetItem(source, 1);
-        if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
-            Py_DECREF(o1);
-            Py_DECREF(o2);
-            goto error;
-        }
-        **obj = T(PyInt_AsLong(o1), PyInt_AsLong(o2));
-        Py_DECREF(o1);
-        Py_DECREF(o2);
-        return True;
-    }
-
- error:
-    wxString msg;
-    msg.Printf(wxT("Expected a 2-tuple of integers or a %s object."), name);
-    PyErr_SetString(PyExc_TypeError, msg.mb_str());
-    return False;
-}
-
-
-

 // Other helpful stuff
 // Other helpful stuff

+bool wxPyCheckForApp();
+bool wxPyTestDisplayAvailable();
+

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

+PyObject* wxArrayDouble2PyList_helper(const wxArrayDouble& arr);

 
 #endif // wxPyUSE_EXPORTED_API
 
 
 #endif // wxPyUSE_EXPORTED_API
 


@@ -236,7 +284,7 @@ PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr);
 #ifndef wxPyUSE_EXPORTED_API
 
 class wxPyCallback : public wxObject {
 #ifndef wxPyUSE_EXPORTED_API
 
 class wxPyCallback : public wxObject {

-    DECLARE_ABSTRACT_CLASS(wxPyCallback);
+    DECLARE_ABSTRACT_CLASS(wxPyCallback)

 public:
     wxPyCallback(PyObject* func);
     wxPyCallback(const wxPyCallback& other);
 public:
     wxPyCallback(PyObject* func);
     wxPyCallback(const wxPyCallback& other);


@@ -261,7 +309,7 @@ public:
     wxPyEvtSelfRef();
     ~wxPyEvtSelfRef();
 
     wxPyEvtSelfRef();
     ~wxPyEvtSelfRef();
 

-    void SetSelf(PyObject* self, bool clone=False);
+    void SetSelf(PyObject* self, bool clone=false);

     PyObject* GetSelf() const;
     bool GetCloned() const { return m_cloned; }
 
     PyObject* GetSelf() const;
     bool GetCloned() const { return m_cloned; }
 


@@ -305,7 +353,7 @@ void wxPyClientData_dtor(wxPyClientData* self);
 void wxPyUserData_dtor(wxPyUserData* self);
 void wxPyOORClientData_dtor(wxPyOORClientData* self);
 wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block);
 void wxPyUserData_dtor(wxPyUserData* self);
 void wxPyOORClientData_dtor(wxPyOORClientData* self);
 wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block);

-
+wxPyCBInputStream* wxPyCBInputStream_copy(wxPyCBInputStream* other);

 
 //---------------------------------------------------------------------------
 // Export a C API in a struct.  Other modules will be able to load this from
 
 //---------------------------------------------------------------------------
 // Export a C API in a struct.  Other modules will be able to load this from


@@ -313,51 +361,9 @@ wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block);
 // in another shared library.
 
 class wxPyCallbackHelper;
 // in another shared library.
 
 class wxPyCallbackHelper;

-struct swig_type_info;
-struct swig_const_info;
-
-typedef double (*py_objasdbl_conv)(PyObject *obj);
-
-// Make SunCC happy and make typedef's for these that are extern "C"
-typedef swig_type_info* (*p_SWIG_Python_TypeRegister_t)(swig_type_info *);
-typedef swig_type_info* (*p_SWIG_Python_TypeCheck_t)(char *c, swig_type_info *);
-typedef void*           (*p_SWIG_Python_TypeCast_t)(swig_type_info *, void *);
-typedef swig_type_info* (*p_SWIG_Python_TypeDynamicCast_t)(swig_type_info *, void **);
-typedef const char*     (*p_SWIG_Python_TypeName_t)(const swig_type_info *);
-typedef swig_type_info* (*p_SWIG_Python_TypeQuery_t)(const char *);
-typedef void            (*p_SWIG_Python_TypeClientData_t)(swig_type_info *, void *);
-typedef PyObject*       (*p_SWIG_Python_newvarlink_t)(void);
-typedef void            (*p_SWIG_Python_addvarlink_t)(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-typedef int             (*p_SWIG_Python_ConvertPtr_t)(PyObject *, void **, swig_type_info *, int);
-typedef int             (*p_SWIG_Python_ConvertPacked_t)(PyObject *, void *, int sz, swig_type_info *, int);
-typedef char*           (*p_SWIG_Python_PackData_t)(char *c, void *, int);
-typedef char*           (*p_SWIG_Python_UnpackData_t)(char *c, void *, int);
-typedef PyObject*       (*p_SWIG_Python_NewPointerObj_t)(void *, swig_type_info *,int own);
-typedef PyObject*       (*p_SWIG_Python_NewPackedObj_t)(void *, int sz, swig_type_info *);
-typedef void            (*p_SWIG_Python_InstallConstants_t)(PyObject *d, swig_const_info constants[]);
-typedef void*           (*p_SWIG_Python_MustGetPtr_t)(PyObject *, swig_type_info *, int, int);
-

 
 struct wxPyCoreAPI {
 
 
 struct wxPyCoreAPI {
 

-    p_SWIG_Python_TypeRegister_t       p_SWIG_Python_TypeRegister;
-    p_SWIG_Python_TypeCheck_t          p_SWIG_Python_TypeCheck;
-    p_SWIG_Python_TypeCast_t           p_SWIG_Python_TypeCast;
-    p_SWIG_Python_TypeDynamicCast_t    p_SWIG_Python_TypeDynamicCast;
-    p_SWIG_Python_TypeName_t           p_SWIG_Python_TypeName;
-    p_SWIG_Python_TypeQuery_t          p_SWIG_Python_TypeQuery;
-    p_SWIG_Python_TypeClientData_t     p_SWIG_Python_TypeClientData;
-    p_SWIG_Python_newvarlink_t         p_SWIG_Python_newvarlink;
-    p_SWIG_Python_addvarlink_t         p_SWIG_Python_addvarlink;
-    p_SWIG_Python_ConvertPtr_t         p_SWIG_Python_ConvertPtr;
-    p_SWIG_Python_ConvertPacked_t      p_SWIG_Python_ConvertPacked;
-    p_SWIG_Python_PackData_t           p_SWIG_Python_PackData;
-    p_SWIG_Python_UnpackData_t         p_SWIG_Python_UnpackData;
-    p_SWIG_Python_NewPointerObj_t      p_SWIG_Python_NewPointerObj;
-    p_SWIG_Python_NewPackedObj_t       p_SWIG_Python_NewPackedObj;
-    p_SWIG_Python_InstallConstants_t   p_SWIG_Python_InstallConstants;
-    p_SWIG_Python_MustGetPtr_t         p_SWIG_Python_MustGetPtr;
-    

     bool                (*p_wxPyCheckSwigType)(const wxChar* className);
     PyObject*           (*p_wxPyConstructObject)(void* ptr, const wxChar* className, int setThisOwn);
     bool                (*p_wxPyConvertSwigPtr)(PyObject* obj, void **ptr, const wxChar* className);
     bool                (*p_wxPyCheckSwigType)(const wxChar* className);
     PyObject*           (*p_wxPyConstructObject)(void* ptr, const wxChar* className, int setThisOwn);
     bool                (*p_wxPyConvertSwigPtr)(PyObject* obj, void **ptr, const wxChar* className);


@@ -365,8 +371,8 @@ struct wxPyCoreAPI {
         
     PyThreadState*      (*p_wxPyBeginAllowThreads)();
     void                (*p_wxPyEndAllowThreads)(PyThreadState* state);
         
     PyThreadState*      (*p_wxPyBeginAllowThreads)();
     void                (*p_wxPyEndAllowThreads)(PyThreadState* state);

-    void                (*p_wxPyBeginBlockThreads)();
-    void                (*p_wxPyEndBlockThreads)();
+    wxPyBlock_t         (*p_wxPyBeginBlockThreads)();
+    void                (*p_wxPyEndBlockThreads)(wxPyBlock_t blocked);

 
     PyObject*           (*p_wxPy_ConvertList)(wxListBase* list);
 
 
     PyObject*           (*p_wxPy_ConvertList)(wxListBase* list);
 


@@ -388,20 +394,20 @@ 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_wxPoint2D_helper)(PyObject* source, wxPoint2DDouble** obj);
+    bool                (*p_wxPoint2D_helper)(PyObject* source, wxPoint2D** obj);

 
     
     bool                (*p_wxPySimple_typecheck)(PyObject* source, const wxChar* classname, int seqLen);
     bool                (*p_wxColour_typecheck)(PyObject* source);
 
     void                (*p_wxPyCBH_setCallbackInfo)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
 
     
     bool                (*p_wxPySimple_typecheck)(PyObject* source, const wxChar* classname, int seqLen);
     bool                (*p_wxColour_typecheck)(PyObject* source);
 
     void                (*p_wxPyCBH_setCallbackInfo)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);

-    bool                (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
+    bool                (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name, bool setGuard);

     int                 (*p_wxPyCBH_callCallback)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
     PyObject*           (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
     void                (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
 
     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_wxPyMake_wxObject)(wxObject* source, bool checkEvtHandler);
-    PyObject*           (*p_wxPyMake_wxSizer)(wxSizer* source);
+    PyObject*           (*p_wxPyMake_wxObject)(wxObject* source, bool setThisOwn, bool checkEvtHandler);
+    PyObject*           (*p_wxPyMake_wxSizer)(wxSizer* source, bool setThisOwn);

     void                (*p_wxPyPtrTypeMap_Add)(const char* commonName, const char* ptrName);
     bool                (*p_wxPy2int_seq_helper)(PyObject* source, int* i1, int* i2);
     bool                (*p_wxPy4int_seq_helper)(PyObject* source, int* i1, int* i2, int* i3, int* i4);
     void                (*p_wxPyPtrTypeMap_Add)(const char* commonName, const char* ptrName);
     bool                (*p_wxPy2int_seq_helper)(PyObject* source, int* i1, int* i2);
     bool                (*p_wxPy4int_seq_helper)(PyObject* source, int* i1, int* i2, int* i3, int* i4);


@@ -413,16 +419,26 @@ struct wxPyCoreAPI {
     void                (*p_wxPyOORClientData_dtor)(wxPyOORClientData*);
 
     wxPyCBInputStream*  (*p_wxPyCBInputStream_create)(PyObject *py, bool block);
     void                (*p_wxPyOORClientData_dtor)(wxPyOORClientData*);
 
     wxPyCBInputStream*  (*p_wxPyCBInputStream_create)(PyObject *py, bool block);

-
+    wxPyCBInputStream*  (*p_wxPyCBInputStream_copy)(wxPyCBInputStream* other);
+    

     bool                (*p_wxPyInstance_Check)(PyObject* obj);
     bool                (*p_wxPySwigInstance_Check)(PyObject* obj);
     bool                (*p_wxPyInstance_Check)(PyObject* obj);
     bool                (*p_wxPySwigInstance_Check)(PyObject* obj);

-    
+
+    bool                (*p_wxPyCheckForApp)();
+
+    // Add all new items at the end...
+    PyObject*           (*p_wxArrayDoublePyList_helper)(const wxArrayDouble& arr);
+    wxPoint2D*          (*p_wxPoint2D_LIST_helper)(PyObject* source, size_t* npoints);
+    bool                (*p_wxRect2D_helper)(PyObject* source, wxRect2D** obj);
+

 };
 
 };
 

+

 #ifdef wxPyUSE_EXPORTED_API
 // 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;
 #ifdef wxPyUSE_EXPORTED_API
 // 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;

+inline wxPyCoreAPI* wxPyGetCoreAPIPtr();

 #endif // wxPyUSE_EXPORTED_API
 
 //---------------------------------------------------------------------------
 #endif // wxPyUSE_EXPORTED_API
 
 //---------------------------------------------------------------------------


@@ -437,7 +453,7 @@ public:
 
     ~wxPyUserData() {
 #ifdef wxPyUSE_EXPORTED_API
 
     ~wxPyUserData() {
 #ifdef wxPyUSE_EXPORTED_API

-        wxPyCoreAPIPtr->p_wxPyUserData_dtor(this);
+        wxPyGetCoreAPIPtr()->p_wxPyUserData_dtor(this);

 #else
         wxPyUserData_dtor(this);
 #endif
 #else
         wxPyUserData_dtor(this);
 #endif


@@ -449,19 +465,22 @@ public:
 // A wxClientData that holds a refernece to a Python object
 class wxPyClientData : public wxClientData {
 public:
 // A wxClientData that holds a refernece to a Python object
 class wxPyClientData : public wxClientData {
 public:

-    wxPyClientData(PyObject* obj) {
+    wxPyClientData(PyObject* obj, bool incref=true) {

         m_obj = obj;
         m_obj = obj;

-        Py_INCREF(m_obj);
+        m_incRef = incref;
+        if (incref)
+            Py_INCREF(m_obj);

     }
     }

-

     ~wxPyClientData() {
     ~wxPyClientData() {

+

 #ifdef wxPyUSE_EXPORTED_API
 #ifdef wxPyUSE_EXPORTED_API

-        wxPyCoreAPIPtr->p_wxPyClientData_dtor(this);
+        wxPyGetCoreAPIPtr()->p_wxPyClientData_dtor(this);

 #else
         wxPyClientData_dtor(this);
 #endif
     }
     PyObject* m_obj;
 #else
         wxPyClientData_dtor(this);
 #endif
     }
     PyObject* m_obj;

+    bool      m_incRef;

 };
 
 
 };
 
 


@@ -469,12 +488,12 @@ public:
 // OOR magic on the Python Object.
 class wxPyOORClientData : public wxPyClientData {
 public:
 // OOR magic on the Python Object.
 class wxPyOORClientData : public wxPyClientData {
 public:

-    wxPyOORClientData(PyObject* obj)
-        : wxPyClientData(obj) {}
-
+    wxPyOORClientData(PyObject* obj, bool incref=true)
+        : wxPyClientData(obj, incref) {}

     ~wxPyOORClientData() {
     ~wxPyOORClientData() {

+

 #ifdef wxPyUSE_EXPORTED_API
 #ifdef wxPyUSE_EXPORTED_API

-        wxPyCoreAPIPtr->p_wxPyOORClientData_dtor(this);
+        wxPyGetCoreAPIPtr()->p_wxPyOORClientData_dtor(this);

 #else
         wxPyOORClientData_dtor(this);
 #endif
 #else
         wxPyOORClientData_dtor(this);
 #endif


@@ -482,6 +501,39 @@ public:
 };
 
 
 };
 
 

+//---------------------------------------------------------------------------
+// A wxImageHandler that can be derived from in Python.
+//
+
+class wxPyImageHandler: public wxImageHandler {
+protected:
+    PyObject *m_self;
+
+    // used for interning method names as PyStrings
+    static PyObject* m_DoCanRead_Name;
+    static PyObject* m_GetImageCount_Name;
+    static PyObject* m_LoadFile_Name;
+    static PyObject* m_SaveFile_Name;
+
+    // converstion helpers
+    PyObject* py_InputStream(wxInputStream* stream);
+    PyObject* py_Image(wxImage* image);
+    PyObject* py_OutputStream(wxOutputStream* stream);
+
+public:
+    wxPyImageHandler();
+    ~wxPyImageHandler();
+    void _SetSelf(PyObject *self);
+    
+    virtual bool LoadFile(wxImage* image, wxInputStream& stream,
+                          bool verbose=true, int index=-1 );
+    virtual bool SaveFile(wxImage* image, wxOutputStream& stream,
+                          bool verbose=true );
+    virtual int GetImageCount(wxInputStream& stream );
+    virtual bool DoCanRead(wxInputStream &stream);
+};
+
+

 //---------------------------------------------------------------------------
 // This class holds an instance of a Python Shadow Class object and assists
 // with looking up and invoking Python callback methods from C++ virtual
 //---------------------------------------------------------------------------
 // This class holds an instance of a Python Shadow Class object and assists
 // with looking up and invoking Python callback methods from C++ virtual


@@ -498,22 +550,25 @@ public:
         m_class = NULL;
         m_self = NULL;
         m_lastFound = NULL;
         m_class = NULL;
         m_self = NULL;
         m_lastFound = NULL;

-        m_incRef = False;
+        m_incRef = false;

     }
 
     ~wxPyCallbackHelper() {
 #ifdef wxPyUSE_EXPORTED_API
     }
 
     ~wxPyCallbackHelper() {
 #ifdef wxPyUSE_EXPORTED_API

-        wxPyCoreAPIPtr->p_wxPyCBH_delete(this);
+        wxPyGetCoreAPIPtr()->p_wxPyCBH_delete(this);

 #else
         wxPyCBH_delete(this);
 #endif
     }
 
 #else
         wxPyCBH_delete(this);
 #endif
     }
 

-    void        setSelf(PyObject* self, PyObject* klass, int incref=True);
-    bool        findCallback(const char* name) const;
+    void        setSelf(PyObject* self, PyObject* klass, int incref=true);
+    bool        findCallback(const char* name, bool setGuard=true) const;

     int         callCallback(PyObject* argTuple) const;
     PyObject*   callCallbackObj(PyObject* argTuple) const;
     PyObject*   GetLastFound() const { return m_lastFound; }
     int         callCallback(PyObject* argTuple) const;
     PyObject*   callCallbackObj(PyObject* argTuple) const;
     PyObject*   GetLastFound() const { return m_lastFound; }

+
+    void        setRecursionGuard(PyObject* method) const;
+    void        clearRecursionGuard(PyObject* method) const;

     
 private:
     PyObject*   m_self;
     
 private:
     PyObject*   m_self;


@@ -526,7 +581,7 @@ private:
 
 
 void wxPyCBH_setCallbackInfo(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);
+bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name, bool setGuard=true);

 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 void wxPyCBH_delete(wxPyCallbackHelper* cbh);


@@ -558,7 +613,7 @@ enum {
 
 class wxPyApp: public wxApp
 {
 
 class wxPyApp: public wxApp
 {

-    DECLARE_ABSTRACT_CLASS(wxPyApp);
+    DECLARE_ABSTRACT_CLASS(wxPyApp)

 
 public:
     wxPyApp();
 
 public:
     wxPyApp();


@@ -572,11 +627,13 @@ public:
     virtual bool OnInitGui();
     virtual int OnExit();
 #ifdef __WXDEBUG__
     virtual bool OnInitGui();
     virtual int OnExit();
 #ifdef __WXDEBUG__

-    virtual void OnAssert(const wxChar *file,
-                          int line,
-                          const wxChar *cond,
-                          const wxChar *msg);
+    virtual void OnAssertFailure(const wxChar *file,
+                                 int line,
+                                 const wxChar *func,
+                                 const wxChar *cond,
+                                 const wxChar *msg);

 #endif
 #endif

+    virtual void ExitMainLoop();

     // virtual int FilterEvent(wxEvent& event); // This one too????
 
     // For catching Apple Events
     // virtual int FilterEvent(wxEvent& event); // This one too????
 
     // For catching Apple Events


@@ -618,162 +675,122 @@ extern wxPyApp *wxPythonApp;
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__(CBNAME)                        \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__(CBNAME)                        \

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

 
 
 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)                         \
     void CLASS::CBNAME() {                                              \
         bool found;                                                     \
 
 
 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)                         \
     void CLASS::CBNAME() {                                              \
         bool found;                                                     \

-        wxPyBeginBlockThreads();                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));        \

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME();                                           \
         if (! found)                                                    \
             PCLASS::CBNAME();                                           \

-    }                                                                   \
-    void CLASS::base_##CBNAME() {                                       \
-        PCLASS::CBNAME();                                               \
-    }
+    }                                                                   
+
+#define DEC_PYCALLBACK_VOID_(CBNAME)                                    \
+            DEC_PYCALLBACK__(CBNAME)
+
+#define IMP_PYCALLBACK_VOID_(CLASS, PCLASS, CBNAME)                     \
+             IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)

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

-    bool CBNAME(int a, int b);                                  \
-    bool base_##CBNAME(int a, int b)
+    bool 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=False, found;                                         \
-        wxPyBeginBlockThreads();                    \
+        bool rval=false, found;                                         \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \

-        wxPyEndBlockThreads();                                     \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             rval = PCLASS::CBNAME(a,b);                                 \
         return rval;                                                    \
         if (! found)                                                    \
             rval = PCLASS::CBNAME(a,b);                                 \
         return rval;                                                    \

-    }                                                                   \
-    bool CLASS::base_##CBNAME(int a, int b) {                           \
-        return PCLASS::CBNAME(a,b);                                     \
-    }
-
-//---------------------------------------------------------------------------
-
-#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)                      \
     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_VOID_INTINT(CBNAME)                      \

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

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

-        wxPyBeginBlockThreads();                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));  \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));  \

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a,b);                                        \
         if (! found)                                                    \
             PCLASS::CBNAME(a,b);                                        \

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

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

-    void CBNAME(int a);                                         \
-    void base_##CBNAME(int a)
+    void CBNAME(int a)

 
 
 #define IMP_PYCALLBACK_VOID_INT(CLASS, PCLASS, CBNAME)                  \
     void CLASS::CBNAME(int a) {                                         \
         bool found;                                                     \
 
 
 #define IMP_PYCALLBACK_VOID_INT(CLASS, PCLASS, CBNAME)                  \
     void CLASS::CBNAME(int a) {                                         \
         bool found;                                                     \

-        wxPyBeginBlockThreads();                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));     \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));     \

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a);                                          \
         if (! found)                                                    \
             PCLASS::CBNAME(a);                                          \

-    }                                                                   \
-    void CLASS::base_##CBNAME(int a) {                                  \
-        PCLASS::CBNAME(a);                                              \
-    }
+    }                 

 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_VOID_INT4(CBNAME)                                \
 
 //---------------------------------------------------------------------------
 
 #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)
+    void 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;                                                     \
 
 
 #define IMP_PYCALLBACK_VOID_INT4(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(int a, int b, int c, int d) {                    \
         bool found;                                                     \

-        wxPyBeginBlockThreads();                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiii)",a,b,c,d));  \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiii)",a,b,c,d));  \

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a,b,c,d);                                    \
         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)                                \
 
 //---------------------------------------------------------------------------
 #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)
+    void 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;                                                     \
 
 
 #define IMP_PYCALLBACK_VOID_INT5(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(int a, int b, int c, int d, int e) {             \
         bool found;                                                     \

-        wxPyBeginBlockThreads();                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiiii)",a,b,c,d,e));  \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiiii)",a,b,c,d,e));  \

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a,b,c,d,e);                                  \
         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)                              \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_VOID_INTPINTP_const(CBNAME)                              \

-    void CBNAME(int* a, int* b) const;                                          \
-    void base_##CBNAME(int* a, int* b) const
+    void 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;                                                             \
 
 
 #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();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -795,27 +812,22 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                                  \

         if (! found)                                                            \
             PCLASS::CBNAME(a,b);                                                \
         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)                                       \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_SIZE_const(CBNAME)                                       \

-    wxSize CBNAME() const;                                                      \
-    wxSize base_##CBNAME() const
+    wxSize 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);                                           \
 
 
 #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();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -837,59 +849,47 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             return PCLASS::CBNAME();                                            \
         else                                                                    \
             return rval;                                                        \
         if (! found)                                                            \
             return PCLASS::CBNAME();                                            \
         else                                                                    \
             return rval;                                                        \

-    }                                                                           \
-    wxSize CLASS::base_##CBNAME() const {                                       \
-        return PCLASS::CBNAME();                                                \
-    }
-
+    }                    

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

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

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

-        bool rval=False, found;                                         \
-        wxPyBeginBlockThreads();                                        \
+        bool rval=false, found;                                         \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             rval = PCLASS::CBNAME(a);                                   \
         return rval;                                                    \
         if (! found)                                                    \
             rval = PCLASS::CBNAME(a);                                   \
         return rval;                                                    \

-    }                                                                   \
-    bool CLASS::base_##CBNAME(bool a) {                                 \
-        return PCLASS::CBNAME(a);                                       \

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

-    bool CBNAME(int a);                                         \
-    bool base_##CBNAME(int a)
+    bool 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=False, found;                                         \
-        wxPyBeginBlockThreads();                                        \
+        bool rval=false, found;                                         \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             rval = PCLASS::CBNAME(a);                                   \
         return rval;                                                    \
         if (! found)                                                    \
             rval = PCLASS::CBNAME(a);                                   \
         return rval;                                                    \

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

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


@@ -898,395 +898,328 @@ extern wxPyApp *wxPythonApp;
     bool CBNAME(int a)
 
 
     bool CBNAME(int a)
 
 

-#define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
-    bool CLASS::CBNAME(int a) {                                         \
-        bool rval=False;                                                \
-        wxPyBeginBlockThreads();                    \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
-            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
-        else rval = False;                                              \
-        wxPyEndBlockThreads();                                     \
-        return rval;                                                    \
+#define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)                     \
+    bool CLASS::CBNAME(int a) {                                                 \
+        bool rval=false;                                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));      \
+        else rval = false;                                                      \
+        wxPyEndBlockThreads(blocked);                                           \
+        return rval;                                                            \

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

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

 
 
 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)                       \
     void CLASS::CBNAME(wxDC& a) {                                       \
         bool found;                                                     \
 
 
 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)                       \
     void CLASS::CBNAME(wxDC& a) {                                       \
         bool found;                                                     \

-        wxPyBeginBlockThreads();                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \

-            PyObject* obj = wxPyMake_wxObject(&a);                      \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                \

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));  \
             Py_DECREF(obj);                                             \
         }                                                               \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));  \
             Py_DECREF(obj);                                             \
         }                                                               \

-        wxPyEndBlockThreads();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a);                                          \
         if (! found)                                                    \
             PCLASS::CBNAME(a);                                          \

-    }                                                                   \
-    void CLASS::base_##CBNAME(wxDC& a) {                                \
-        PCLASS::CBNAME(a);                                              \
-    }
-
+    }                   

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

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

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

-        wxPyBeginBlockThreads();                    \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \

-            PyObject* obj = wxPyMake_wxObject(&a);                      \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                \

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

-        wxPyEndBlockThreads();                                     \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a, b);                                       \
         if (! found)                                                    \
             PCLASS::CBNAME(a, b);                                       \

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

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

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

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

-        wxPyBeginBlockThreads();                    \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \

-            PyObject* obj = wxPyMake_wxObject(&a);                      \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                \

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

-        wxPyEndBlockThreads();                                     \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a, b);                                       \
         if (! found)                                                    \
             PCLASS::CBNAME(a, b);                                       \

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

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

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

 
 
 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(double a, double b) {                            \
         bool found;                                                     \
 
 
 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(double a, double b) {                            \
         bool found;                                                     \

-        wxPyBeginBlockThreads();                    \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));  \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));  \

-        wxPyEndBlockThreads();                                     \
+        wxPyEndBlockThreads(blocked);                                   \

         if (! found)                                                    \
             PCLASS::CBNAME(a, b);                                       \
         if (! found)                                                    \
             PCLASS::CBNAME(a, b);                                       \

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

 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
 
 //---------------------------------------------------------------------------
 
 #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 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 found;                                                     \
 
 
 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(double a, double b, int c, int d) {              \
         bool found;                                                     \

-        wxPyBeginBlockThreads();                    \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",      \
                                                        a,b,c,d));       \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",      \
                                                        a,b,c,d));       \

-        wxPyEndBlockThreads();                                     \
+        wxPyEndBlockThreads(blocked);                                   \

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

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

 
 //---------------------------------------------------------------------------
 
 #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 base_##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)

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

-        wxPyBeginBlockThreads();                                    \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                         \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \

-            PyObject* obj = wxPyMake_wxObject(&a);                                      \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                                \

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

-        wxPyEndBlockThreads();                                                     \
+        wxPyEndBlockThreads(blocked);                                                   \

         if (! found)                                                                    \
             PCLASS::CBNAME(a, b, c, d, e, f);                                           \
         if (! found)                                                                    \
             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);                                               \
-    }
+    }                                                                   

 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
 
 //---------------------------------------------------------------------------
 
 #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 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 found;                                                                     \
 
 
 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
         bool found;                                                                     \

-        wxPyBeginBlockThreads();                                    \
-        bool rval=False;                                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                         \
+        bool rval=false;                                                                \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \

-            PyObject* obj = wxPyMake_wxObject(&a);                                      \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                                \

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

-        wxPyEndBlockThreads();                                                     \
+        wxPyEndBlockThreads(blocked);                                                   \

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

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

 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
 
 //---------------------------------------------------------------------------
 
 #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 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 found;                                                             \
 
 
 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \
                                                 (int)a,b,c,d,e));               \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \
                                                 (int)a,b,c,d,e));               \

-        wxPyEndBlockThreads();                                             \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a, b, c, d, e);                                      \
         if (! found)                                                            \
             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);                                          \
-    }
+    }                                                    

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

-    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 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 found;                                                             \
 
 
 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(&a);                              \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                        \

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

-        wxPyEndBlockThreads();                                             \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a, b, c, d, e);                                      \
         if (! found)                                                            \
             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);                                          \

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

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

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

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(&a);                              \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                        \

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

-        wxPyEndBlockThreads();                                             \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a, b);                                               \
         if (! found)                                                            \
             PCLASS::CBNAME(a, b);                                               \

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

     }
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
     }
 
 //---------------------------------------------------------------------------
 
 #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 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 found;                                                             \
 
 
 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
                 int e, int f) {                                                 \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(a);                               \
+            PyObject* obj = wxPyMake_wxObject(a,false);                         \

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

-        wxPyEndBlockThreads();                                             \
+        wxPyEndBlockThreads(blocked);                                           \

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

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

 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
 
 //---------------------------------------------------------------------------
 
 #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 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 found;                                                             \
 
 
 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(a);                               \
+            PyObject* obj = wxPyMake_wxObject(a,false);                         \

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

-        wxPyEndBlockThreads();                                             \
+        wxPyEndBlockThreads(blocked);                                           \

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

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

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

-    void CBNAME(double a, double b, int c);             \
-    void base_##CBNAME(double a, double b, int c)
+    void 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;                                                             \
 
 
 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \
     void CLASS::CBNAME(double a, double b, int c) {                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));      \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));      \

-        wxPyEndBlockThreads();                                             \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a, b, c);                                            \
         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)                     \
 
 //---------------------------------------------------------------------------
 
 #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 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 found;                                                             \
 
 
 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

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

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

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

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

 
 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                           \
     void CLASS::CBNAME(const wxString& a)  {                                    \
         bool found;                                                             \
 
 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                           \
     void CLASS::CBNAME(const wxString& a)  {                                    \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* s = wx2PyString(a);                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));            \
             Py_DECREF(s);                                                       \
         }                                                                       \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* s = wx2PyString(a);                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));            \
             Py_DECREF(s);                                                       \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \
         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \

-    }                                                                           \
-    void CLASS::base_##CBNAME(const wxString& a) {                              \
-        PCLASS::CBNAME(a);                                                      \

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

-    bool CBNAME(const wxString& a);                     \
-    bool base_##CBNAME(const wxString& a)
+    bool 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=False;                                                        \
+        bool rval=false;                                                        \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* s = wx2PyString(a);                                       \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
             Py_DECREF(s);                                                       \
         }                                                                       \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* s = wx2PyString(a);                                       \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
             Py_DECREF(s);                                                       \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \

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

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


@@ -1296,14 +1229,14 @@ extern wxPyApp *wxPythonApp;
 
 #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=False;                                                        \
-        wxPyBeginBlockThreads();                                                \
+        bool rval=false;                                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* s = wx2PyString(a);                                       \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
             Py_DECREF(s);                                                       \
         }                                                                       \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* s = wx2PyString(a);                                       \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
             Py_DECREF(s);                                                       \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

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


@@ -1315,7 +1248,7 @@ extern wxPyApp *wxPythonApp;
 #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;                                                          \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             PyObject* s = wx2PyString(a);                                       \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             PyObject* s = wx2PyString(a);                                       \


@@ -1326,21 +1259,20 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

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

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

 
 #define IMP_PYCALLBACK_STRING_STRING(CLASS, PCLASS, CBNAME)                     \
     wxString CLASS::CBNAME(const wxString& a)  {                                \
         wxString rval;                                                          \
         bool found;                                                             \
 
 #define IMP_PYCALLBACK_STRING_STRING(CLASS, PCLASS, CBNAME)                     \
     wxString CLASS::CBNAME(const wxString& a)  {                                \
         wxString rval;                                                          \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             PyObject* s = wx2PyString(a);                                       \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             PyObject* s = wx2PyString(a);                                       \


@@ -1351,9 +1283,9 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \

-        wxPyEndBlockThreads();                                                  \

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


@@ -1365,7 +1297,7 @@ extern wxPyApp *wxPythonApp;
 #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;                                                          \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             PyObject* s = wx2PyString(a);                                       \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             PyObject* s = wx2PyString(a);                                       \


@@ -1376,21 +1308,20 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

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

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

 
 #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=False;                                                        \
+        bool rval=false;                                                        \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* s1 = wx2PyString(a);                                      \
             PyObject* s2 = wx2PyString(b);                                      \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* s1 = wx2PyString(a);                                      \
             PyObject* s2 = wx2PyString(b);                                      \


@@ -1398,26 +1329,22 @@ extern wxPyApp *wxPythonApp;
             Py_DECREF(s1);                                                      \
             Py_DECREF(s2);                                                      \
         }                                                                       \
             Py_DECREF(s1);                                                      \
             Py_DECREF(s2);                                                      \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a, b);                                        \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME(a, b);                                        \
         return rval;                                                            \

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

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

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

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

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -1426,26 +1353,22 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \

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

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

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

 
 #define IMP_PYCALLBACK_STRING__const(CLASS, PCLASS, CBNAME)                     \
     wxString CLASS::CBNAME() const {                                            \
         wxString rval;                                                          \
         bool found;                                                             \
 
 #define IMP_PYCALLBACK_STRING__const(CLASS, PCLASS, CBNAME)                     \
     wxString CLASS::CBNAME() const {                                            \
         wxString rval;                                                          \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -1454,14 +1377,11 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \

-    }                                                                           \
-    wxString CLASS::base_##CBNAME() const {                                     \
-        return PCLASS::CBNAME();                                                \
-    }
+    }                      

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


@@ -1471,7 +1391,7 @@ extern wxPyApp *wxPythonApp;
 #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;                                                          \

-        wxPyBeginBlockThreads();                            \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -1480,7 +1400,7 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rval;                                                            \
     }
 
         return rval;                                                            \
     }
 


@@ -1492,7 +1412,7 @@ extern wxPyApp *wxPythonApp;
 #define IMP_PYCALLBACK_STRING__constpure(CLASS, PCLASS, CBNAME)                 \
     wxString CLASS::CBNAME() const {                                            \
         wxString rval;                                                          \
 #define IMP_PYCALLBACK_STRING__constpure(CLASS, PCLASS, CBNAME)                 \
     wxString CLASS::CBNAME() const {                                            \
         wxString rval;                                                          \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -1501,7 +1421,7 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rval;                                                            \
     }
 
         return rval;                                                            \
     }
 


@@ -1513,66 +1433,113 @@ extern wxPyApp *wxPythonApp;
 
 #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;                                                        \
-        wxPyBeginBlockThreads();                                                \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
-            PyObject* obj = wxPyConstructObject((void*)&a, wxT("wxHtmlTag"), 0);     \
+        bool rval=false;                                                        \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if (wxPyCBH_findCallback2(m_myInst, #CBNAME, false)) {                  \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT("wxHtmlTag"), 0);\

             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

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

-    void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);                        \
-    void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y)
+    void 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;                                                             \
 
 #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)cell, wxT("wxHtmlCell"), 0);  \
+            PyObject* obj = wxPyMake_wxObject(cell, 0);                         \

             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y));  \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y));  \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(cell, x, y);                                         \
         if (! found)                                                            \
             PCLASS::CBNAME(cell, x, y);                                         \

+    }                                                  
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK__COLOUR(CBNAME)                                      \
+    void CBNAME(const wxColour& c);
+
+#define IMP_PYCALLBACK__COLOUR(CLASS, PCLASS, CBNAME)                           \
+    void CLASS::CBNAME(const wxColour& c) {                                     \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)&c, wxT("wxColour"), 0); \
+            wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj));        \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            PCLASS::CBNAME(c);                                                  \

     }                                                                           \
     }                                                                           \

-    void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {         \
-        PCLASS::CBNAME(cell, x, y);                                             \
-    }

 
 

+//---------------------------------------------------------------------------
+#define DEC_PYCALLBACK__INTCOLOUR(CBNAME)                                       \
+    void CBNAME(int a, const wxColour& c);
+
+#define IMP_PYCALLBACK__INTCOLOUR(CLASS, PCLASS, CBNAME)                        \
+    void CLASS::CBNAME(int a, const wxColour& c) {                              \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyConstructObject((void*)&c, wxT("wxColour"), 0); \
+            wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)",a, obj));    \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a, c);                                               \
+    }                                                                           \

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

-#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 DEC_PYCALLBACK__INTFONT(CBNAME)       \
+    void CBNAME(int a, const wxFont& c);

 
 

-#define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
-    void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
+#define IMP_PYCALLBACK__INTFONT(CLASS, PCLASS, CBNAME)                          \
+    void CLASS::CBNAME(int a, const wxFont& c) {                                \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         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));  \
+            PyObject* obj = wxPyConstructObject((void*)&c, wxT("wxFont"), 0);   \
+            wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)",a, obj));    \

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

-            Py_DECREF(o2);                                                      \

         }                                                                       \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
         if (! found)                                                            \

-            PCLASS::CBNAME(cell, x, y, e);                                      \
+            PCLASS::CBNAME(a, c);                                               \

     }                                                                           \
     }                                                                           \

-    void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {         \
-        PCLASS::CBNAME(cell, x, y, e);                                          \
-    }

 
 

+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BOOL_CELLINTINTME(CBNAME)                                    \
+    bool CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e)
+
+#define IMP_PYCALLBACK_BOOL_CELLINTINTME(CLASS, PCLASS, CBNAME)                         \
+    bool CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) { \
+        bool rval=false, found;                                                         \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                  \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
+            PyObject* obj = wxPyMake_wxObject(cell, 0);                                 \
+            PyObject* o2  = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0);     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiiO)",obj,x,y,o2));  \
+            Py_DECREF(obj);                                                             \
+            Py_DECREF(o2);                                                              \
+        }                                                                               \
+        wxPyEndBlockThreads(blocked);                                                   \
+        if (! found)                                                                    \
+            rval = PCLASS::CBNAME(cell, x, y, e);                                       \
+        return rval;                                                                    \
+    }  

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


@@ -1583,10 +1550,10 @@ extern wxPyApp *wxPythonApp;
 
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
     void CLASS::CBNAME() {                                                      \
 
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
     void CLASS::CBNAME() {                                                      \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

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


@@ -1599,7 +1566,7 @@ extern wxPyApp *wxPythonApp;
     wxSize CLASS::CBNAME() {                                                    \
         const char* errmsg = #CBNAME " should return a 2-tuple of integers or a wxSize object."; \
         wxSize rval(0,0);                                                       \
     wxSize CLASS::CBNAME() {                                                    \
         const char* errmsg = #CBNAME " should return a 2-tuple of integers or a wxSize object."; \
         wxSize rval(0,0);                                                       \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             wxSize*   ptr;                                                      \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             wxSize*   ptr;                                                      \


@@ -1608,6 +1575,7 @@ extern wxPyApp *wxPythonApp;
                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize")))       \
                     rval = *ptr;                                                \
                 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {    \
                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize")))       \
                     rval = *ptr;                                                \
                 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {    \

+                    PyErr_Clear();                                              \

                     PyObject* o1 = PySequence_GetItem(ro, 0);                   \
                     PyObject* o2 = PySequence_GetItem(ro, 1);                   \
                     if (PyNumber_Check(o1) && PyNumber_Check(o2))               \
                     PyObject* o1 = PySequence_GetItem(ro, 0);                   \
                     PyObject* o2 = PySequence_GetItem(ro, 1);                   \
                     if (PyNumber_Check(o1) && PyNumber_Check(o2))               \


@@ -1623,205 +1591,179 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

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

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

 
 
 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                        \
     bool CLASS::CBNAME(wxWindow* a) {                                           \
 
 
 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                        \
     bool CLASS::CBNAME(wxWindow* a) {                                           \

-        bool rval=False;                                                        \
+        bool rval=false;                                                        \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(a);                               \
+            PyObject* obj = wxPyMake_wxObject(a,false);                         \

             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \

-    }                                                                           \
-    bool CLASS::base_##CBNAME(wxWindow* a) {                                    \
-        return PCLASS::CBNAME(a);                                               \
-    }
+    }                       

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

-    bool CBNAME(wxWindow* a, wxDC& b);                                  \
-    bool base_##CBNAME(wxWindow* a, wxDC& b)
+    bool CBNAME(wxWindow* a, wxDC& b)

 
 
 
 

-#define IMP_PYCALLBACK_BOOL_WXWINDC(CLASS, PCLASS, CBNAME)                        \
+#define IMP_PYCALLBACK_BOOL_WXWINDC(CLASS, PCLASS, CBNAME)                      \

     bool CLASS::CBNAME(wxWindow* a, wxDC& b) {                                  \
     bool CLASS::CBNAME(wxWindow* a, wxDC& b) {                                  \

-        bool rval=False;                                                        \
+        bool rval=false;                                                        \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* win = wxPyMake_wxObject(a);                               \
-            PyObject* dc  = wxPyMake_wxObject(&b);                              \
+            PyObject* win = wxPyMake_wxObject(a,false);                         \
+            PyObject* dc  = wxPyMake_wxObject(&b,false);                        \

             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));\
             Py_DECREF(win);                                                     \
             Py_DECREF(dc);                                                      \
         }                                                                       \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));\
             Py_DECREF(win);                                                     \
             Py_DECREF(dc);                                                      \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a, b);                                        \
         return rval;                                                            \
         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)                      \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_VOID_WXWINBASE(CBNAME)                      \

-    void CBNAME(wxWindowBase* a);                                  \
-    void base_##CBNAME(wxWindowBase* a)
+    void CBNAME(wxWindowBase* a)

 
 
 #define IMP_PYCALLBACK_VOID_WXWINBASE(CLASS, PCLASS, CBNAME)                    \
     void CLASS::CBNAME(wxWindowBase* a) {                                       \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK_VOID_WXWINBASE(CLASS, PCLASS, CBNAME)                    \
     void CLASS::CBNAME(wxWindowBase* a) {                                       \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(a);                               \
+            PyObject* obj = wxPyMake_wxObject(a,false);                         \

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \
         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \

-    }                                                                           \
-    void CLASS::base_##CBNAME(wxWindowBase* a) {                                \
-        PCLASS::CBNAME(a);                                                      \
-    }
+    }                 

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

-    bool CBNAME();                                        \
-    bool base_##CBNAME()
+    bool CBNAME()

 
 
 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                             \
     bool CLASS::CBNAME() {                                                      \
 
 
 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                             \
     bool CLASS::CBNAME() {                                                      \

-        bool rval=False;                                                        \
+        bool rval=false;                                                        \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \

-    }                                                                           \
-    bool CLASS::base_##CBNAME() {                                               \
-        return PCLASS::CBNAME();                                                \
-    }
+    }       

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

-    bool CBNAME() const;                                        \
-    bool base_##CBNAME() const
+    bool CBNAME() const

 
 
 #define IMP_PYCALLBACK_BOOL_const(CLASS, PCLASS, CBNAME)                        \
     bool CLASS::CBNAME() const {                                                \
 
 
 #define IMP_PYCALLBACK_BOOL_const(CLASS, PCLASS, CBNAME)                        \
     bool CLASS::CBNAME() const {                                                \

-        bool rval=False;                                                        \
+        bool rval=false;                                                        \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \

-    }                                                                           \
-    bool CLASS::base_##CBNAME() const {                                         \
-        return PCLASS::CBNAME();                                                \
-    }
+    }      

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

-    wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);        \
-    wxDragResult base_##CBNAME(wxCoord x, wxCoord y, wxDragResult def)
+    wxDragResult 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;                                                             \
 
 
 #define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                         \
     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {          \
         int rval=0;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a, b, c);                                     \
         return (wxDragResult)rval;                                              \
         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)                        \
     wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location)
 
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \
     wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location)
 

-#define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
-    wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
-        wxPyBeginBlockThreads();                                        \
-        wxFSFile* rval=0;                                               \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \
-            PyObject* ro;                                               \
-            PyObject* obj = wxPyMake_wxObject(&a);                      \
-            PyObject* s = wx2PyString(b);                               \
-            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)",\
-                                         obj, s));                      \
-            if (ro) {                                                   \
-                wxPyConvertSwigPtr(ro, (void **)&rval, wxT("wxFSFILE"));\
-                Py_DECREF(ro);                                          \
-            }                                                           \
-            Py_DECREF(obj);                                             \
-            Py_DECREF(s);                                               \
-        }                                                               \
-        wxPyEndBlockThreads();                                          \
-        return rval;                                                    \
+#define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)                 \
+    wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        wxFSFile* rval=0;                                                       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* ro;                                                       \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                        \
+            PyObject* s = wx2PyString(b);                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)",        \
+                                         obj, s));                              \
+            if (ro) {                                                           \
+                wxPyConvertSwigPtr(ro, (void **)&rval, wxT("wxFSFile"));        \
+                /* release ownership of the C++ wx.FSFile object. */            \
+                PyObject_SetAttrString(ro, "thisown", Py_False);                \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+            Py_DECREF(obj);                                                     \
+            Py_DECREF(s);                                                       \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        return rval;                                                            \

     };
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
     };
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \

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

 
 
 
 

-#define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \
-    bool CLASS::CBNAME(wxDragResult a) {                                \
-        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);                                   \
-        return rval;                                                    \
-    }                                                                   \
-    bool CLASS::base_##CBNAME(wxDragResult a) {                         \
-        return PCLASS::CBNAME(a);                                       \
-    }
+#define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                           \
+    bool CLASS::CBNAME(wxDragResult a) {                                        \
+        bool rval=false;                                                        \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }        

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


@@ -1829,15 +1771,15 @@ extern wxPyApp *wxPythonApp;
     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) {  \
-        wxPyBeginBlockThreads();                                        \
-        int rval=0;                                                     \
-        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
+#define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)                    \
+    wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {          \
+        wxPyBlock_t blocked = 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));\

-        wxPyEndBlockThreads();                                          \
-        return (wxDragResult)rval;                                      \
-    }                                                                   \
+        wxPyEndBlockThreads(blocked);                                           \
+        return (wxDragResult)rval;                                              \
+    }                                                                           \

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


@@ -1846,75 +1788,66 @@ extern wxPyApp *wxPythonApp;
 
 #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=False;                                                \
-        wxPyBeginBlockThreads();                                        \
+        bool rval=false;                                                \
+        wxPyBlock_t blocked = 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);                                               \
         }                                                               \
         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();                                          \
+        wxPyEndBlockThreads(blocked);                                   \

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

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

 
 
 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
     size_t CLASS::CBNAME() {                                                    \
         size_t rval=0;                                                          \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
     size_t CLASS::CBNAME() {                                                    \
         size_t rval=0;                                                          \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \

-    }                                                                           \
-    size_t CLASS::base_##CBNAME() {                                             \
-        return PCLASS::CBNAME();                                                \
-    }
+    }            

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

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

 
 
 
 

-#define IMP_PYCALLBACK_SIZET__const(CLASS, PCLASS, CBNAME)                       \
+#define IMP_PYCALLBACK_SIZET__const(CLASS, PCLASS, CBNAME)                      \

     size_t CLASS::CBNAME() const {                                              \
         size_t rval=0;                                                          \
         bool found;                                                             \
     size_t CLASS::CBNAME() const {                                              \
         size_t rval=0;                                                          \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \

-    }                                                                           \
-    size_t CLASS::base_##CBNAME() const {                                       \
-        return PCLASS::CBNAME();                                                \
-    }
+    }         

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

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

 
 
 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
         wxDataFormat rval=0;                                                    \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
         wxDataFormat rval=0;                                                    \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             wxDataFormat* ptr;                                                  \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             wxDataFormat* ptr;                                                  \


@@ -1925,89 +1858,74 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \

-    }                                                                           \
-    wxDataFormat  CLASS::base_##CBNAME(size_t a) {                              \
-        return PCLASS::CBNAME(a);                                               \
-    }
+    }         

 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \

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

 
 
 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
     void CLASS::CBNAME(const Type& a) {                                         \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
     void CLASS::CBNAME(const Type& a) {                                         \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);      \

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \
         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \

-    }                                                                           \
-    void CLASS::base_##CBNAME(const Type& a) {                                  \
-        PCLASS::CBNAME(a);                                                      \
-    }
+    }           

 
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
 
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK__any(CBNAME, Type)          \

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

 
 
 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
     void CLASS::CBNAME(Type& a) {                                               \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
     void CLASS::CBNAME(Type& a) {                                               \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);      \

             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \
         if (! found)                                                            \
             PCLASS::CBNAME(a);                                                  \

-    }                                                                           \
-    void CLASS::base_##CBNAME(Type& a) {                                        \
-        PCLASS::CBNAME(a);                                                      \
-    }
+    }              

 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \

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

 
 
 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
     bool CLASS::CBNAME(Type& a) {                                               \
 
 
 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
     bool CLASS::CBNAME(Type& a) {                                               \

-        bool rv=False;                                                          \
+        bool rv=false;                                                          \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);      \

             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rv = PCLASS::CBNAME(a);                                             \
         return rv;                                                              \
         if (! found)                                                            \
             rv = PCLASS::CBNAME(a);                                             \
         return rv;                                                              \

-    }                                                                           \
-    bool CLASS::base_##CBNAME(Type& a) {                                        \
-        return PCLASS::CBNAME(a);                                               \
-    }
+    }          

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


@@ -2017,28 +1935,27 @@ extern wxPyApp *wxPythonApp;
 
 #define IMP_PYCALLBACK_bool_anypure(CLASS, PCLASS, CBNAME, Type)                \
     bool CLASS::CBNAME(Type& a) {                                               \
 
 #define IMP_PYCALLBACK_bool_anypure(CLASS, PCLASS, CBNAME, Type)                \
     bool CLASS::CBNAME(Type& a) {                                               \

-        bool rv=False;                                                          \
-        wxPyBeginBlockThreads();                                                \
+        bool rv=false;                                                          \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

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

-            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);           \
+            PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0);      \

             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rv;                                                              \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME)                                  \
         return rv;                                                              \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME)                                  \

-    wxString CBNAME(long a, long b) const;                                      \
-    wxString base_##CBNAME(long a, long b) const
+    wxString CBNAME(long a, long b) const

 
 #define IMP_PYCALLBACK_STRING_LONGLONG(CLASS, PCLASS, CBNAME)                   \
     wxString CLASS::CBNAME(long a, long b) const {                              \
         wxString rval;                                                          \
         bool found;                                                             \
 
 #define IMP_PYCALLBACK_STRING_LONGLONG(CLASS, PCLASS, CBNAME)                   \
     wxString CLASS::CBNAME(long a, long b) const {                              \
         wxString rval;                                                          \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \


@@ -2047,27 +1964,23 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a,b);                                         \
         return rval;                                                            \
         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)                                         \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_INT_LONG(CBNAME)                                         \

-    int CBNAME(long a) const;                                                   \
-    int base_##CBNAME(long a) const
+    int CBNAME(long a) const

 
 
 #define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME)                          \
     int CLASS::CBNAME(long a) const {                                           \
         int rval=-1;                                                            \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME)                          \
     int CLASS::CBNAME(long a) const {                                           \
         int rval=-1;                                                            \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \


@@ -2076,28 +1989,119 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a);                                           \
+        return rval;                                                            \
+    }     
+
+
+#define DEC_PYCALLBACK_INT_LONG_virtual(CBNAME)                                 \
+    int CBNAME(long a) const;
+
+
+#define IMP_PYCALLBACK_INT_LONG_virtual(CLASS, PCLASS, CBNAME)                  \
+    int CLASS::CBNAME(long a) const {                                           \
+        int rval=-1;    /* this rval is important for OnGetItemImage */         \
+        bool found;                                                             \
+        wxPyBlock_t blocked = 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(blocked);                                           \
+        return rval;                                                            \
+    }  
+
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_INT_INT(CBNAME)          \
+    int CBNAME(int a)
+
+
+#define IMP_PYCALLBACK_INT_INT(CLASS, PCLASS, CBNAME)                           \
+    int CLASS::CBNAME(int a) {                                                  \
+        int rval=-1;                                                            \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a));     \
+            if (ro) {                                                           \
+                rval = PyInt_AsLong(ro);                                        \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \

-    }                                                                           \
-    int CLASS::base_##CBNAME(long a) const {                                    \
-        return PCLASS::CBNAME(a);                                               \

     }
 
     }
 

+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_INT_LONGLONG(CBNAME)                                     \
+    int CBNAME(long a, long b) const
+
+
+#define IMP_PYCALLBACK_INT_LONGLONG(CLASS, PCLASS, CBNAME)                      \
+    int CLASS::CBNAME(long a, long b) const {                                   \
+        int rval=-1;                                                            \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \
+            if (ro) {                                                           \
+                rval = PyInt_AsLong(ro);                                        \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a, b);                                        \
+        return rval;                                                            \
+    }          
+
+
+#define DEC_PYCALLBACK_INT_LONGLONG_virtual(CBNAME)                             \
+    int CBNAME(long a, long b) const;
+
+
+#define IMP_PYCALLBACK_INT_LONGLONG_virtual(CLASS, PCLASS, CBNAME)              \
+    int CLASS::CBNAME(long a, long b) const {                                   \
+        int rval=-1;    /* this rval is important for OnGetItemImage */         \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \
+            if (ro) {                                                           \
+                rval = PyInt_AsLong(ro);                                        \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        return rval;                                                            \
+    }  
+

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

-    wxListItemAttr*  CBNAME(long a) const;                                      \
-    wxListItemAttr*  base_##CBNAME(long a) const
+    wxListItemAttr*  CBNAME(long a) const

 
 
 #define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME)                     \
     wxListItemAttr *CLASS::CBNAME(long a) const {                               \
         wxListItemAttr *rval = NULL;                                            \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME)                     \
     wxListItemAttr *CLASS::CBNAME(long a) const {                               \
         wxListItemAttr *rval = NULL;                                            \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             wxListItemAttr* ptr;                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             wxListItemAttr* ptr;                                                \


@@ -2108,26 +2112,22 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
         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)                                          \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_ME(CBNAME)                                          \

-    bool CBNAME(wxMouseEvent& e);                                               \
-    bool base_##CBNAME(wxMouseEvent& e)
+    bool CBNAME(wxMouseEvent& e)

 
 #define IMP_PYCALLBACK_BOOL_ME(CLASS, PCLASS, CBNAME)                           \
     bool CLASS::CBNAME(wxMouseEvent& e) {                                       \
 
 #define IMP_PYCALLBACK_BOOL_ME(CLASS, PCLASS, CBNAME)                           \
     bool CLASS::CBNAME(wxMouseEvent& e) {                                       \

-        bool rval=False;                                                        \
+        bool rval=false;                                                        \

         bool found;                                                             \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             PyObject* obj  = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0); \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             PyObject* obj  = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0); \


@@ -2138,15 +2138,11 @@ extern wxPyApp *wxPythonApp;
             }                                                                   \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             }                                                                   \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             return PCLASS::CBNAME(e);                                           \
         return rval;                                                            \
         if (! found)                                                            \
             return PCLASS::CBNAME(e);                                           \
         return rval;                                                            \

-    }                                                                           \
-    bool CLASS::base_##CBNAME(wxMouseEvent& e) {                                \
-        return PCLASS::CBNAME(e);                                               \
-    }
-
+    }       

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


@@ -2156,7 +2152,7 @@ extern wxPyApp *wxPythonApp;
 #define IMP_PYCALLBACK_WIZPG__pure(CLASS, PCLASS, CBNAME)                       \
     wxWizardPage* CLASS::CBNAME() const {                                       \
         wxWizardPage* rv = NULL;                                                \
 #define IMP_PYCALLBACK_WIZPG__pure(CLASS, PCLASS, CBNAME)                       \
     wxWizardPage* CLASS::CBNAME() const {                                       \
         wxWizardPage* rv = NULL;                                                \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -2165,7 +2161,7 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rv;                                                              \
     }
 
         return rv;                                                              \
     }
 


@@ -2177,7 +2173,7 @@ extern wxPyApp *wxPythonApp;
 #define IMP_PYCALLBACK_BITMAP__pure(CLASS, PCLASS, CBNAME)                      \
     wxBitmap CLASS::CBNAME() const {                                            \
         wxBitmap rv;                                                            \
 #define IMP_PYCALLBACK_BITMAP__pure(CLASS, PCLASS, CBNAME)                      \
     wxBitmap CLASS::CBNAME() const {                                            \
         wxBitmap rv;                                                            \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             wxBitmap* ptr;                                                      \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             wxBitmap* ptr;                                                      \


@@ -2188,7 +2184,7 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rv;                                                              \
     }
 
         return rv;                                                              \
     }
 


@@ -2200,7 +2196,7 @@ extern wxPyApp *wxPythonApp;
 #define IMP_PYCALLBACK_OBJECT__pure(CLASS, PCLASS, CBNAME)                      \
     wxObject* CLASS::CBNAME() {                                                 \
         wxObject* rv = NULL;                                                    \
 #define IMP_PYCALLBACK_OBJECT__pure(CLASS, PCLASS, CBNAME)                      \
     wxObject* CLASS::CBNAME() {                                                 \
         wxObject* rv = NULL;                                                    \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \


@@ -2209,7 +2205,7 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rv;                                                              \
     }
 
         return rv;                                                              \
     }
 


@@ -2221,7 +2217,7 @@ extern wxPyApp *wxPythonApp;
 #define IMP_PYCALLBACK_OBJECT_STRING_pure(CLASS, PCLASS, CBNAME)                \
     wxObject* CLASS::CBNAME(const wxString& a) {                                \
         wxObject* rv = NULL;                                                    \
 #define IMP_PYCALLBACK_OBJECT_STRING_pure(CLASS, PCLASS, CBNAME)                \
     wxObject* CLASS::CBNAME(const wxString& a) {                                \
         wxObject* rv = NULL;                                                    \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* so = wx2PyString(a);                                      \
             PyObject* ro;                                                       \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
             PyObject* so = wx2PyString(a);                                      \
             PyObject* ro;                                                       \


@@ -2232,7 +2228,7 @@ extern wxPyApp *wxPythonApp;
             }                                                                   \
             Py_DECREF(so);                                                      \
         }                                                                       \
             }                                                                   \
             Py_DECREF(so);                                                      \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rv;                                                              \
     }
 
         return rv;                                                              \
     }
 


@@ -2244,14 +2240,14 @@ extern wxPyApp *wxPythonApp;
 
 #define IMP_PYCALLBACK_BOOL_NODE_pure(CLASS, PCLASS, CBNAME)                    \
     bool CLASS::CBNAME(wxXmlNode* a) {                                          \
 
 #define IMP_PYCALLBACK_BOOL_NODE_pure(CLASS, PCLASS, CBNAME)                    \
     bool CLASS::CBNAME(wxXmlNode* a) {                                          \

-        bool rv=False;                                                          \
-        wxPyBeginBlockThreads();                                                \
+        bool rv=false;                                                          \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

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

-            PyObject* obj = wxPyConstructObject((void*)a, wxT("wxXmlNode"), 0);      \
+            PyObject* obj = wxPyConstructObject((void*)a, wxT("wxXmlNode"), 0); \

             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
             Py_DECREF(obj);                                                     \
         }                                                                       \
             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
             Py_DECREF(obj);                                                     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rv;                                                              \
     }                                                                           \
 
         return rv;                                                              \
     }                                                                           \
 


@@ -2265,56 +2261,47 @@ extern wxPyApp *wxPythonApp;
     wxCoord CLASS::CBNAME(size_t a) const {                                     \
         wxCoord rval=0;                                                         \
         bool found;                                                             \
     wxCoord CLASS::CBNAME(size_t a) const {                                     \
         wxCoord rval=0;                                                         \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
         }                                                                       \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rval;                                                            \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_VOID_SIZETSIZET_const(CBNAME)                            \
         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
+    void 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;                                                             \
 
 
 #define IMP_PYCALLBACK_VOID_SIZETSIZET_const(CLASS, PCLASS, CBNAME)             \
     void CLASS::CBNAME(size_t a, size_t b) const {                              \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));          \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));          \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a,b);                                                \
         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)                       \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_COORD_const(CBNAME)                       \

-    wxCoord CBNAME() const;                                      \
-    wxCoord base_##CBNAME() const
+    wxCoord CBNAME() const

 
 
 #define IMP_PYCALLBACK_COORD_const(CLASS, PCLASS, CBNAME)                       \
     wxCoord CLASS::CBNAME() const {                                             \
         wxCoord rval=0;                                                         \
         bool found;                                                             \
 
 
 #define IMP_PYCALLBACK_COORD_const(CLASS, PCLASS, CBNAME)                       \
     wxCoord CLASS::CBNAME() const {                                             \
         wxCoord rval=0;                                                         \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME();                                            \
         return rval;                                                            \

-    }                                                                           \
-    wxCoord CLASS::base_##CBNAME() const {                                      \
-        return PCLASS::CBNAME();                                                \

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


@@ -2322,57 +2309,89 @@ extern wxPyApp *wxPythonApp;
 #define DEC_PYCALLBACK__DCRECTSIZET_constpure(CBNAME)                           \
     void CBNAME(wxDC& a, const wxRect& b, size_t c) const;
 
 #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;                                                             \
 #define IMP_PYCALLBACK__DCRECTSIZET_constpure(CLASS, PCLASS, CBNAME)            \
     void CLASS::CBNAME(wxDC& a, const wxRect& b, size_t c) const {              \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(&a);                              \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                        \

             PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
             PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \

-            Py_DECREF(obj);                                                     \
+            Py_DECREF(obj); Py_DECREF(ro);                                      \

         }                                                                       \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

     }                                                                           \
 
     }                                                                           \
 

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

 
 

-#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 DEC_PYCALLBACK__DCRECTSIZET_const(CBNAME)                               \
+    void 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;                                                             \
 
 #define IMP_PYCALLBACK__DCRECTSIZET_const(CLASS, PCLASS, CBNAME)                \
     void CLASS::CBNAME(wxDC& a, const wxRect& b, size_t c) const {              \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyMake_wxObject(&a);                              \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                        \

             PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
             PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \

-            Py_DECREF(obj);                                                     \
+            Py_DECREF(obj); Py_DECREF(ro);                                      \

         }                                                                       \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             PCLASS::CBNAME(a,b,c);                                              \
         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);                                                  \
-    }
+    }            
+

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

+// Same as the above set, but the wxRect is not const
+
+#define DEC_PYCALLBACK__DCRECTSIZET2_constpure(CBNAME)                          \
+    void CBNAME(wxDC& a, wxRect& b, size_t c) const;
+
+#define IMP_PYCALLBACK__DCRECTSIZET2_constpure(CLASS, PCLASS, CBNAME)           \
+    void CLASS::CBNAME(wxDC& a, wxRect& b, size_t c) const {                    \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                        \
+            PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
+            Py_DECREF(obj); Py_DECREF(ro);                                      \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+    }                                                                           \
+
+
+
+#define DEC_PYCALLBACK__DCRECTSIZET2_const(CBNAME)                              \
+    void CBNAME(wxDC& a, wxRect& b, size_t c) const
+
+#define IMP_PYCALLBACK__DCRECTSIZET2_const(CLASS, PCLASS, CBNAME)               \
+    void CLASS::CBNAME(wxDC& a, wxRect& b, size_t c) const {                    \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyMake_wxObject(&a,false);                        \
+            PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0);    \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
+            Py_DECREF(obj); Py_DECREF(ro);                                      \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            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 DEC_PYCALLBACK_STRING_SIZET(CBNAME)     \
+    wxString CBNAME(size_t a) const

 
 #define IMP_PYCALLBACK_STRING_SIZET(CLASS, PCLASS, CBNAME)                      \
     wxString CLASS::CBNAME(size_t a) const {                                    \
         wxString rval;                                                          \
         bool found;                                                             \
 
 #define IMP_PYCALLBACK_STRING_SIZET(CLASS, PCLASS, CBNAME)                      \
     wxString CLASS::CBNAME(size_t a) const {                                    \
         wxString rval;                                                          \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \


@@ -2381,14 +2400,11 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
         if (! found)                                                            \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \

-    }                                                                           \
-    wxString CLASS::base_##CBNAME(size_t a) const {                             \
-        return PCLASS::CBNAME(a);                                               \
-    }
+    }               

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


@@ -2399,7 +2415,7 @@ extern wxPyApp *wxPythonApp;
     wxString CLASS::CBNAME(size_t a) const {                                    \
         wxString rval;                                                          \
         bool found;                                                             \
     wxString CLASS::CBNAME(size_t a) const {                                    \
         wxString rval;                                                          \
         bool found;                                                             \

-        wxPyBeginBlockThreads();                                                \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \

         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \


@@ -2408,10 +2424,89 @@ extern wxPyApp *wxPythonApp;
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \
                 Py_DECREF(ro);                                                  \
             }                                                                   \
         }                                                                       \

-        wxPyEndBlockThreads();                                                  \
+        wxPyEndBlockThreads(blocked);                                           \

         return rval;                                                            \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 
         return rval;                                                            \
     }                                                                           \
 
 //---------------------------------------------------------------------------
 

+#define DEC_PYCALLBACK_VIZATTR_(CBNAME)                                         \
+    wxVisualAttributes  CBNAME() const
+
+
+#define IMP_PYCALLBACK_VIZATTR_(CLASS, PCLASS, CBNAME)                          \
+    wxVisualAttributes CLASS::CBNAME() const {                                  \
+        wxVisualAttributes rval;                                                \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                                 \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            wxVisualAttributes* ptr;                                            \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxVisualAttributes"))) \
+                    rval = *ptr;                                                \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME();                                            \
+        return rval;                                                            \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_FONT_INT(CBNAME)                                         \
+    wxFont CBNAME(int a)
+
+#define IMP_PYCALLBACK_FONT_INT(CLASS, PCLASS, CBNAME)                          \
+    wxFont CLASS::CBNAME(int a) {                                               \
+        wxFont rv;                                                              \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* ro;                                                       \
+            wxFont* ptr;                                                        \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \
+            if (ro) {                                                           \
+                if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxFont")))       \
+                    rv = *ptr;                                                  \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            rv = PCLASS::CBNAME(a);                                             \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_COLOUR_INT(CBNAME)                                       \
+    wxColour CBNAME(int a)
+
+#define IMP_PYCALLBACK_COLOUR_INT(CLASS, PCLASS, CBNAME)                        \
+    wxColour CLASS::CBNAME(int a) {                                             \
+        wxColour rv;                                                            \
+        bool found;                                                             \
+        wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
+            PyObject* ro;                                                       \
+            wxColour* ptr;                                                      \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \
+            if (ro) {                                                           \
+                if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxColour")))     \
+                    rv = *ptr;                                                  \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads(blocked);                                           \
+        if (! found)                                                            \
+            rv = PCLASS::CBNAME(a);                                             \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+

 #endif
 #endif