]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/src/helpers.h
highlight the focused item in non report mode too
[wxWidgets.git] / wxPython / src / helpers.h
index 63f9c255a2a63feec882a898a9425afd5be6542c..8258295e4631cfb675186639098d08fa3fa7b44e 100644 (file)
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 
-#if defined(__WXMSW__)
-#       define HELPEREXPORT __declspec(dllexport)
-#else
-#       define HELPEREXPORT
-#endif
-
 typedef unsigned char byte;
 
 typedef unsigned char byte;
 
-//----------------------------------------------------------------------
 
 class wxPyApp: public wxApp
 {
 
 class wxPyApp: public wxApp
 {
@@ -50,9 +43,7 @@ public:
     ~wxPyApp();
     int  MainLoop(void);
     bool OnInit(void);
     ~wxPyApp();
     int  MainLoop(void);
     bool OnInit(void);
-//#    void AfterMainLoop(void);
 };
 };
-
 extern wxPyApp *wxPythonApp;
 
 //----------------------------------------------------------------------
 extern wxPyApp *wxPythonApp;
 
 //----------------------------------------------------------------------
@@ -61,31 +52,28 @@ void      __wxPreStart();
 PyObject* __wxStart(PyObject*, PyObject* args);
 void      __wxCleanup();
 
 PyObject* __wxStart(PyObject*, PyObject* args);
 void      __wxCleanup();
 
-extern PyObject* wxPython_dict;
+//extern PyObject* wxPython_dict;
 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
 
 void wxPyEventThunker(wxObject*, wxEvent& event);
 
 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
 
 void wxPyEventThunker(wxObject*, wxEvent& event);
 
-HELPEREXPORT PyObject* wxPyConstructObject(void* ptr,
-                                           const char* className,
-                                           int setThisOwn=0);
-HELPEREXPORT bool wxPyRestoreThread();
-HELPEREXPORT void wxPySaveThread(bool doSave);
-HELPEREXPORT PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
-HELPEREXPORT long wxPyGetWinHandle(wxWindow* win);
+PyObject* wxPyConstructObject(void* ptr,
+                              const char* className,
+                              int setThisOwn=0);
+PyObject* wxPyConstructObject(void* ptr,
+                              const char* className,
+                              PyObject* klass,
+                              int setThisOwn=0);
+PyObject*  wxPyClassExists(const char* className);
+PyObject*  wxPyMake_wxObject(wxObject* source);
+void       wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
+
+bool wxPyRestoreThread();
+void wxPySaveThread(bool doSave);
+PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
+long wxPyGetWinHandle(wxWindow* win);
 
 
-//----------------------------------------------------------------------
 
 
-class wxPyUserData : public wxObject {
-public:
-    wxPyUserData(PyObject* obj) { m_obj = obj; Py_INCREF(m_obj); }
-    ~wxPyUserData() {
-        bool doSave = wxPyRestoreThread();
-        Py_DECREF(m_obj);
-        wxPySaveThread(doSave);
-    }
-    PyObject* m_obj;
-};
 
 //----------------------------------------------------------------------
 // Handle wxInputStreams by Joerg Baumann
 
 //----------------------------------------------------------------------
 // Handle wxInputStreams by Joerg Baumann
@@ -97,7 +85,7 @@ WX_DECLARE_LIST(wxString, wxStringPtrList);
 
 // C++ class wxPyInputStream to act as base for python class wxInputStream
 // Use it in python like a python file object
 
 // C++ class wxPyInputStream to act as base for python class wxInputStream
 // Use it in python like a python file object
-class wxPyInputStream{
+class wxPyInputStream {
 public:
     // underlying wxInputStream
     wxInputStream* wxi;
 public:
     // underlying wxInputStream
     wxInputStream* wxi;
@@ -128,20 +116,20 @@ public:
 //----------------------------------------------------------------------
 // These are helpers used by the typemaps
 
 //----------------------------------------------------------------------
 // These are helpers used by the typemaps
 
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-HELPEREXPORT bool wxSize_helper(PyObject* source, wxSize** obj);
-HELPEREXPORT bool wxPoint_helper(PyObject* source, wxPoint** obj);
-HELPEREXPORT bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
-HELPEREXPORT bool wxRect_helper(PyObject* source, wxRect** obj);
-HELPEREXPORT bool wxColour_helper(PyObject* source, wxColour** obj);
+byte* byte_LIST_helper(PyObject* source);
+int* int_LIST_helper(PyObject* source);
+long* long_LIST_helper(PyObject* source);
+char** string_LIST_helper(PyObject* source);
+wxPoint* wxPoint_LIST_helper(PyObject* source, int* npoints);
+wxBitmap** wxBitmap_LIST_helper(PyObject* source);
+wxString* wxString_LIST_helper(PyObject* source);
+wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+
+bool wxSize_helper(PyObject* source, wxSize** obj);
+bool wxPoint_helper(PyObject* source, wxPoint** obj);
+bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
+bool wxRect_helper(PyObject* source, wxRect** obj);
+bool wxColour_helper(PyObject* source, wxColour** obj);
 
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 
@@ -157,13 +145,6 @@ extern "C" char *SWIG_GetPtrObj(PyObject *obj, void **ptr, char *type);
 # pragma warning(disable:4190)
 #endif
 
 # pragma warning(disable:4190)
 #endif
 
-
-
-// Non-const versions to keep SWIG happy.
-extern wxPoint  wxPyDefaultPosition;
-extern wxSize   wxPyDefaultSize;
-extern wxString wxPyEmptyStr;
-
 //----------------------------------------------------------------------
 
 class wxPyCallback : public wxObject {
 //----------------------------------------------------------------------
 
 class wxPyCallback : public wxObject {
@@ -192,42 +173,6 @@ private:
 };
 
 //---------------------------------------------------------------------------
 };
 
 //---------------------------------------------------------------------------
-
-
-
-
-//---------------------------------------------------------------------------
-// This class holds an instance of a Python Shadow Class object and assists
-// with looking up and invoking Python callback methods from C++ virtual
-// method redirections.  For all classes which have virtuals which should be
-// overridable in wxPython, a new subclass is created that contains a
-// wxPyCallbackHelper.
-//
-// TODO: This class should be combined with wxPyCallback defined above.
-//
-
-class HELPEREXPORT wxPyCallbackHelper {
-public:
-    wxPyCallbackHelper();
-    ~wxPyCallbackHelper();
-
-    wxPyCallbackHelper(const wxPyCallbackHelper& other);
-
-    void        setSelf(PyObject* self, PyObject* klass, int incref=TRUE);
-
-    bool        findCallback(const char* name) const;
-    int         callCallback(PyObject* argTuple) const;
-    PyObject*   callCallbackObj(PyObject* argTuple) const;
-
-private:
-    PyObject*   m_self;
-    PyObject*   m_class;
-    PyObject*   m_lastFound;
-    int         m_incRef;
-};
-
-
-//---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
 // These Event classes can be derived from in Python and passed through the
 // event system without loosing anything.  They do this by keeping a reference
 //---------------------------------------------------------------------------
 // These Event classes can be derived from in Python and passed through the
 // event system without loosing anything.  They do this by keeping a reference
@@ -268,6 +213,134 @@ public:
 };
 
 
 };
 
 
+//---------------------------------------------------------------------------
+// Export a C API in a struct.  Other modules will be able to load this from
+// the wxc module and will then have safe access to these functions, even if
+// in another shared library.
+
+class wxPyCallbackHelper;
+
+struct wxPyCoreAPI {
+
+    void        (*p_SWIG_MakePtr)(char*, void*, char*);
+    char*       (*p_SWIG_GetPtr)(char*, void**, char*);
+    char*       (*p_SWIG_GetPtrObj)(PyObject*, void**, char*);
+    void        (*p_SWIG_RegisterMapping)(char*, char*, void *(*cast)(void *));
+    void        (*p_SWIG_addvarlink)(PyObject*, char*, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p));
+    PyObject*   (*p_SWIG_newvarlink)(void);
+
+    void        (*p_wxPySaveThread)(bool);
+    bool        (*p_wxPyRestoreThread)();
+    PyObject*   (*p_wxPyConstructObject)(void *, const char *, int);
+    PyObject*   (*p_wxPy_ConvertList)(wxListBase* list, const char* className);
+
+    byte*       (*p_byte_LIST_helper)(PyObject* source);
+    int*        (*p_int_LIST_helper)(PyObject* source);
+    long*       (*p_long_LIST_helper)(PyObject* source);
+    char**      (*p_string_LIST_helper)(PyObject* source);
+    wxPoint*    (*p_wxPoint_LIST_helper)(PyObject* source, int* npoints);
+    wxBitmap**  (*p_wxBitmap_LIST_helper)(PyObject* source);
+    wxString*   (*p_wxString_LIST_helper)(PyObject* source);
+    wxAcceleratorEntry*   (*p_wxAcceleratorEntry_LIST_helper)(PyObject* source);
+
+    bool        (*p_wxSize_helper)(PyObject* source, wxSize** obj);
+    bool        (*p_wxPoint_helper)(PyObject* source, wxPoint** 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);
+
+    void        (*p_wxPyCBH_setSelf)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
+    bool        (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
+    int         (*p_wxPyCBH_callCallback)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
+    PyObject*   (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
+    void        (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
+
+    PyObject*   (*p_wxPyClassExists)(const char* className);
+    PyObject*   (*p_wxPyMake_wxObject)(wxObject* source);
+    void        (*p_wxPyPtrTypeMap_Add)(const char* commonName, const char* ptrName);
+
+};
+
+#ifdef wxPyUSE_EXPORT
+static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;  // Each module needs one, but may not use it.
+#endif
+
+//---------------------------------------------------------------------------
+// This class holds an instance of a Python Shadow Class object and assists
+// with looking up and invoking Python callback methods from C++ virtual
+// method redirections.  For all classes which have virtuals which should be
+// overridable in wxPython, a new subclass is created that contains a
+// wxPyCallbackHelper.
+//
+
+class wxPyCallbackHelper {
+public:
+    wxPyCallbackHelper(const wxPyCallbackHelper& other);
+
+    wxPyCallbackHelper() {
+        m_class = NULL;
+        m_self = NULL;
+        m_lastFound = NULL;
+        m_incRef = FALSE;
+    }
+
+    ~wxPyCallbackHelper() {
+#ifdef wxPyUSE_EXPORT
+        wxPyCoreAPIPtr->p_wxPyCBH_delete(this);
+#else
+        wxPyCBH_delete(this);
+#endif
+    }
+
+    void        setSelf(PyObject* self, PyObject* klass, int incref=TRUE);
+    bool        findCallback(const char* name) const;
+    int         callCallback(PyObject* argTuple) const;
+    PyObject*   callCallbackObj(PyObject* argTuple) const;
+
+private:
+    PyObject*   m_self;
+    PyObject*   m_class;
+    PyObject*   m_lastFound;
+    int         m_incRef;
+
+    friend      void wxPyCBH_delete(wxPyCallbackHelper* cbh);
+};
+
+
+void wxPyCBH_setSelf(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
+bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name);
+int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
+PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
+void wxPyCBH_delete(wxPyCallbackHelper* cbh);
+
+
+
+//----------------------------------------------------------------------
+
+class wxPyUserData : public wxObject {
+public:
+    wxPyUserData(PyObject* obj) {
+        m_obj = obj;
+        Py_INCREF(m_obj);
+    }
+
+    ~wxPyUserData() {
+        bool doSave;
+#ifdef wxPyUSE_EXPORT
+        doSave = wxPyCoreAPIPtr->p_wxPyRestoreThread();
+        Py_DECREF(m_obj);
+        wxPyCoreAPIPtr->p_wxPySaveThread(doSave);
+#else
+        doSave = wxPyRestoreThread();
+        Py_DECREF(m_obj);
+        wxPySaveThread(doSave);
+#endif
+    }
+    PyObject* m_obj;
+};
+
+
+
 //---------------------------------------------------------------------------
 // These macros are used to implement the virtual methods that should
 // redirect to a Python method if one exists.  The names designate the
 //---------------------------------------------------------------------------
 // These macros are used to implement the virtual methods that should
 // redirect to a Python method if one exists.  The names designate the
@@ -276,7 +349,7 @@ public:
 
 #define PYPRIVATE                                                       \
     void _setSelf(PyObject* self, PyObject* _class, int incref=1) {     \
 
 #define PYPRIVATE                                                       \
     void _setSelf(PyObject* self, PyObject* _class, int incref=1) {     \
-        m_myInst.setSelf(self, _class, incref);                         \
+        wxPyCBH_setSelf(m_myInst, self, _class, incref);                \
     }                                                                   \
     private: wxPyCallbackHelper m_myInst
 
     }                                                                   \
     private: wxPyCallbackHelper m_myInst
 
@@ -290,8 +363,8 @@ public:
 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)         \
     void CLASS::CBNAME() {                              \
         bool doSave = wxPyRestoreThread();              \
 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)         \
     void CLASS::CBNAME() {                              \
         bool doSave = wxPyRestoreThread();              \
-        if (m_myInst.findCallback(#CBNAME))             \
-            m_myInst.callCallback(Py_BuildValue("()")); \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
         else                                            \
             PCLASS::CBNAME();                           \
         wxPySaveThread(doSave);                         \
         else                                            \
             PCLASS::CBNAME();                           \
         wxPySaveThread(doSave);                         \
@@ -311,8 +384,8 @@ public:
     bool CLASS::CBNAME(int a, int b) {                                  \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
     bool CLASS::CBNAME(int a, int b) {                                  \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(ii)",a,b));    \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \
         else                                                            \
             rval = PCLASS::CBNAME(a,b);                                 \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             rval = PCLASS::CBNAME(a,b);                                 \
         wxPySaveThread(doSave);                                         \
@@ -332,8 +405,8 @@ public:
 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
     void CLASS::CBNAME(int a, int b) {                                  \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
     void CLASS::CBNAME(int a, int b) {                                  \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(ii)",a,b));           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));           \
         else                                                            \
             PCLASS::CBNAME(a,b);                                        \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             PCLASS::CBNAME(a,b);                                        \
         wxPySaveThread(doSave);                                         \
@@ -353,8 +426,8 @@ public:
     bool CLASS::CBNAME(int a) {                                         \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
     bool CLASS::CBNAME(int a) {                                         \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(i)",a));       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
         else                                                            \
             rval = PCLASS::CBNAME(a);                                   \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             rval = PCLASS::CBNAME(a);                                   \
         wxPySaveThread(doSave);                                         \
@@ -374,8 +447,8 @@ public:
     bool CLASS::CBNAME(int a) {                                         \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
     bool CLASS::CBNAME(int a) {                                         \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(i)",a));       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
         else rval = FALSE;                                              \
         wxPySaveThread(doSave);                                         \
         return rval;                                                    \
         else rval = FALSE;                                              \
         wxPySaveThread(doSave);                                         \
         return rval;                                                    \
@@ -392,9 +465,9 @@ public:
 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)               \
     void CLASS::CBNAME(wxDC& a) {                               \
         bool doSave = wxPyRestoreThread();                      \
 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)               \
     void CLASS::CBNAME(wxDC& a) {                               \
         bool doSave = wxPyRestoreThread();                      \
-        if (m_myInst.findCallback(#CBNAME)) {                   \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC");    \
-            m_myInst.callCallback(Py_BuildValue("(O)", obj));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                   \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
             Py_DECREF(obj);                                     \
         }                                                       \
         else                                                    \
             Py_DECREF(obj);                                     \
         }                                                       \
         else                                                    \
@@ -417,9 +490,9 @@ public:
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC");            \
-            m_myInst.callCallback(Py_BuildValue("(Oi)", obj, (int)b));  \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
@@ -440,9 +513,9 @@ public:
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC");            \
-            m_myInst.callCallback(Py_BuildValue("(Oi)", obj, (int)b));  \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
@@ -463,8 +536,8 @@ public:
 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)             \
     void CLASS::CBNAME(double a, double b) {                    \
         bool doSave = wxPyRestoreThread();                      \
 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)             \
     void CLASS::CBNAME(double a, double b) {                    \
         bool doSave = wxPyRestoreThread();                      \
-        if (m_myInst.findCallback(#CBNAME))                     \
-            m_myInst.callCallback(Py_BuildValue("(dd)",a,b));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                     \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));   \
         else                                                    \
             PCLASS::CBNAME(a, b);                               \
         wxPySaveThread(doSave);                                 \
         else                                                    \
             PCLASS::CBNAME(a, b);                               \
         wxPySaveThread(doSave);                                 \
@@ -483,8 +556,8 @@ public:
 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(double a, double b, int c, int d) {              \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
     void CLASS::CBNAME(double a, double b, int c, int d) {              \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(ddii)",               \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",               \
                                                        a,b,c,d));       \
         else                                                            \
             PCLASS::CBNAME(a, b, c, d);                                 \
                                                        a,b,c,d));       \
         else                                                            \
             PCLASS::CBNAME(a, b, c, d);                                 \
@@ -504,9 +577,9 @@ public:
 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
         bool doSave = wxPyRestoreThread();                                              \
 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
         bool doSave = wxPyRestoreThread();                                              \
-        if (m_myInst.findCallback(#CBNAME)) {                                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC");                            \
-            m_myInst.callCallback(Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                           \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
             Py_DECREF(obj);                                                             \
         }                                                                               \
         else                                                                            \
             Py_DECREF(obj);                                                             \
         }                                                                               \
         else                                                                            \
@@ -528,9 +601,9 @@ public:
     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
         bool doSave = wxPyRestoreThread();                                              \
         bool rval;                                                                      \
     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
         bool doSave = wxPyRestoreThread();                                              \
         bool rval;                                                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC");                            \
-            rval = m_myInst.callCallback(Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                           \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
             Py_DECREF(obj);                                                             \
         }                                                                               \
         else                                                                            \
             Py_DECREF(obj);                                                             \
         }                                                                               \
         else                                                                            \
@@ -552,8 +625,8 @@ public:
 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
         bool doSave = wxPyRestoreThread();                                      \
 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME))                                     \
-            m_myInst.callCallback(Py_BuildValue("(idii)",                       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \
                                                 (int)a,b,c,d,e));               \
         else                                                                    \
             PCLASS::CBNAME(a, b, c, d, e);                                      \
                                                 (int)a,b,c,d,e));               \
         else                                                                    \
             PCLASS::CBNAME(a, b, c, d, e);                                      \
@@ -573,9 +646,9 @@ public:
 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
         bool doSave = wxPyRestoreThread();                                      \
 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC");                    \
-            m_myInst.callCallback(Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \
         else                                                                    \
             Py_DECREF(obj);                                                     \
         }                                                                       \
         else                                                                    \
@@ -596,9 +669,9 @@ public:
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(wxDC& a, bool b) {                               \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject(&a, "wxDC");            \
-            m_myInst.callCallback(Py_BuildValue("(Oi)", obj, (int)b));  \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
@@ -620,9 +693,9 @@ public:
     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
                 int e, int f) {                                                 \
         bool doSave = wxPyRestoreThread();                                      \
     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
                 int e, int f) {                                                 \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject(a, "wxPyControlPoint");         \
-            m_myInst.callCallback(Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+            PyObject* obj = wxPyMake_wxObject(a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
             Py_DECREF(obj);                                                     \
         }                                                                       \
         else                                                                    \
             Py_DECREF(obj);                                                     \
         }                                                                       \
         else                                                                    \
@@ -644,9 +717,9 @@ public:
 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
         bool doSave = wxPyRestoreThread();                                      \
 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject(a, "wxPyControlPoint");         \
-            m_myInst.callCallback(Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+            PyObject* obj = wxPyMake_wxObject(a); \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
             Py_DECREF(obj);                                                     \
         }                                                                       \
         else                                                                    \
             Py_DECREF(obj);                                                     \
         }                                                                       \
         else                                                                    \
@@ -668,8 +741,8 @@ public:
 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                  \
     void CLASS::CBNAME(double a, double b, int c) {                     \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                  \
     void CLASS::CBNAME(double a, double b, int c) {                     \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(ddi)", a,b,c));       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));       \
         else                                                            \
             PCLASS::CBNAME(a, b, c);                                    \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             PCLASS::CBNAME(a, b, c);                                    \
         wxPySaveThread(doSave);                                         \
@@ -688,8 +761,8 @@ public:
 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
         bool doSave = wxPyRestoreThread();                                      \
 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME))                                     \
-            m_myInst.callCallback(Py_BuildValue("(iddi)", (int)a,b,c,d));       \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));       \
         else                                                                    \
             PCLASS::CBNAME(a, b, c, d);                                         \
         wxPySaveThread(doSave);                                                 \
         else                                                                    \
             PCLASS::CBNAME(a, b, c, d);                                         \
         wxPySaveThread(doSave);                                                 \
@@ -709,8 +782,8 @@ public:
 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(const wxString& a)  {                            \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                   \
     void CLASS::CBNAME(const wxString& a)  {                            \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            m_myInst.callCallback(Py_BuildValue("(s)", a.c_str()));     \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));     \
         else                                                            \
             PCLASS::CBNAME(a);                                          \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             PCLASS::CBNAME(a);                                          \
         wxPySaveThread(doSave);                                         \
@@ -730,8 +803,8 @@ public:
     bool CLASS::CBNAME(const wxString& a)  {                                    \
         bool rval;                                                              \
         bool doSave = wxPyRestoreThread();                                      \
     bool CLASS::CBNAME(const wxString& a)  {                                    \
         bool rval;                                                              \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME))                                     \
-            rval = m_myInst.callCallback(Py_BuildValue("(s)", a.c_str()));      \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));      \
         else                                                                    \
             rval = PCLASS::CBNAME(a);                                           \
         wxPySaveThread(doSave);                                                 \
         else                                                                    \
             rval = PCLASS::CBNAME(a);                                           \
         wxPySaveThread(doSave);                                                 \
@@ -750,8 +823,8 @@ public:
     bool CLASS::CBNAME(const wxString& a)  {                                    \
         bool rval;                                                              \
         bool doSave = wxPyRestoreThread();                                      \
     bool CLASS::CBNAME(const wxString& a)  {                                    \
         bool rval;                                                              \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME))                                     \
-            rval = m_myInst.callCallback(Py_BuildValue("(s)", a.c_str()));      \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));      \
         wxPySaveThread(doSave);                                                 \
         return rval;                                                            \
     }                                                                           \
         wxPySaveThread(doSave);                                                 \
         return rval;                                                            \
     }                                                                           \
@@ -765,9 +838,9 @@ public:
     wxString CLASS::CBNAME(const wxString& a)  {                                \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
     wxString CLASS::CBNAME(const wxString& a)  {                                \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
             PyObject* ro;                                                       \
             PyObject* ro;                                                       \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(s)", a.c_str()));     \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(s)", a.c_str()));     \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
@@ -787,9 +860,9 @@ public:
     wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
     wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
             PyObject* ro;                                                       \
             PyObject* ro;                                                       \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(si)", a.c_str(),b));  \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(si)", a.c_str(),b));  \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
@@ -811,8 +884,8 @@ public:
     bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \
         bool rval;                                                              \
         bool doSave = wxPyRestoreThread();                                      \
     bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \
         bool rval;                                                              \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME))                                     \
-            rval = m_myInst.callCallback(Py_BuildValue("(ss)",                  \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ss)",                  \
                                                        a.c_str(), b.c_str()));  \
         else                                                                    \
             rval = PCLASS::CBNAME(a, b);                                        \
                                                        a.c_str(), b.c_str()));  \
         else                                                                    \
             rval = PCLASS::CBNAME(a, b);                                        \
@@ -834,9 +907,9 @@ public:
     wxString CLASS::CBNAME() {                                                  \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
     wxString CLASS::CBNAME() {                                                  \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
             PyObject* ro;                                                       \
             PyObject* ro;                                                       \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("()"));                 \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
@@ -862,9 +935,9 @@ public:
     wxString CLASS::CBNAME() {                                                  \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
     wxString CLASS::CBNAME() {                                                  \
         wxString rval;                                                          \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
             PyObject* ro;                                                       \
             PyObject* ro;                                                       \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("()"));                 \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
             if (ro) {                                                           \
                 PyObject* str = PyObject_Str(ro);                               \
                 rval = PyString_AsString(str);                                  \
@@ -885,9 +958,9 @@ public:
     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
         bool rval = FALSE;                                                      \
         bool doSave = wxPyRestoreThread();                                      \
     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
         bool rval = FALSE;                                                      \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
-            PyObject* obj = wxPyConstructObject((void*)&a,"wxHtmlTag");         \
-            rval = m_myInst.callCallback(Py_BuildValue("(O)", obj));            \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
+            PyObject* obj = wxPyConstructObject((void*)&a, "wxHtmlTag", 0); \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));            \
             Py_DECREF(obj);                                                     \
         }                                                                       \
         wxPySaveThread(doSave);                                                 \
             Py_DECREF(obj);                                                     \
         }                                                                       \
         wxPySaveThread(doSave);                                                 \
@@ -903,8 +976,8 @@ public:
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
     void CLASS::CBNAME() {                                                      \
         bool doSave = wxPyRestoreThread();                                      \
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
     void CLASS::CBNAME() {                                                      \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME))                                     \
-            m_myInst.callCallback(Py_BuildValue("()"));                         \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                         \
         wxPySaveThread(doSave);                                                 \
     }
 
         wxPySaveThread(doSave);                                                 \
     }
 
@@ -918,10 +991,10 @@ public:
     wxSize CLASS::CBNAME() {                                                    \
         wxSize rval(0,0);                                                       \
         bool doSave = wxPyRestoreThread();                                      \
     wxSize CLASS::CBNAME() {                                                    \
         wxSize rval(0,0);                                                       \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
             PyObject* ro;                                                       \
             wxSize*   ptr;                                                      \
             PyObject* ro;                                                       \
             wxSize*   ptr;                                                      \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("()"));                 \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
             if (ro) {                                                           \
                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))           \
                     rval = *ptr;                                                \
             if (ro) {                                                           \
                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))           \
                     rval = *ptr;                                                \
@@ -943,9 +1016,9 @@ public:
     bool CLASS::CBNAME(wxWindow* a) {                                   \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
     bool CLASS::CBNAME(wxWindow* a) {                                   \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)a,"wxWindow");   \
-            rval = m_myInst.callCallback(Py_BuildValue("(O)", obj));    \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyMake_wxObject(a); \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));    \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
@@ -968,8 +1041,8 @@ public:
     bool CLASS::CBNAME() {                                              \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
     bool CLASS::CBNAME() {                                              \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("()"));          \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));          \
         else                                                            \
             rval = PCLASS::CBNAME();                                    \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             rval = PCLASS::CBNAME();                                    \
         wxPySaveThread(doSave);                                         \
@@ -990,8 +1063,8 @@ public:
     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
         bool doSave = wxPyRestoreThread();                              \
         int rval;                                                       \
     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
         bool doSave = wxPyRestoreThread();                              \
         int rval;                                                       \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(iii)", a,b,c));\
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
         else                                                            \
             rval = PCLASS::CBNAME(a, b, c);                             \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             rval = PCLASS::CBNAME(a, b, c);                             \
         wxPySaveThread(doSave);                                         \
@@ -1010,10 +1083,10 @@ public:
     wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
         bool doSave = wxPyRestoreThread();                              \
         wxFSFile* rval=0;                                               \
     wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
         bool doSave = wxPyRestoreThread();                              \
         wxFSFile* rval=0;                                               \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
             PyObject* ro;                                               \
             PyObject* ro;                                               \
-            PyObject* obj = wxPyConstructObject(&a, "(wxFileSystem");   \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(Os)",         \
+            PyObject* obj = wxPyMake_wxObject(&a); \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Os)",         \
                                           obj, b.c_str()));             \
             if (ro) {                                                   \
                 SWIG_GetPtrObj(ro, (void **)&rval, "_wxFSFILE_p");      \
                                           obj, b.c_str()));             \
             if (ro) {                                                   \
                 SWIG_GetPtrObj(ro, (void **)&rval, "_wxFSFILE_p");      \
@@ -1036,8 +1109,8 @@ public:
     bool CLASS::CBNAME(wxDragResult a) {                                \
         bool doSave = wxPyRestoreThread();                              \
         bool rval;                                                      \
     bool CLASS::CBNAME(wxDragResult a) {                                \
         bool doSave = wxPyRestoreThread();                              \
         bool rval;                                                      \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(i)", a));      \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));      \
         else                                                            \
             rval = PCLASS::CBNAME(a);                                   \
         wxPySaveThread(doSave);                                         \
         else                                                            \
             rval = PCLASS::CBNAME(a);                                   \
         wxPySaveThread(doSave);                                         \
@@ -1057,8 +1130,8 @@ public:
     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
         bool doSave = wxPyRestoreThread();                              \
         int rval;                                                       \
     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
         bool doSave = wxPyRestoreThread();                              \
         int rval;                                                       \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(iii)", a,b,c));\
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
         wxPySaveThread(doSave);                                         \
         return (wxDragResult)rval;                                      \
     }                                                                   \
         wxPySaveThread(doSave);                                         \
         return (wxDragResult)rval;                                      \
     }                                                                   \
@@ -1073,8 +1146,8 @@ public:
     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
         bool rval;                                                      \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME))                             \
-            rval = m_myInst.callCallback(Py_BuildValue("(iis)",a,b,c.c_str()));\
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
         wxPySaveThread(doSave);                                         \
         return rval;                                                    \
     }                                                                   \
         wxPySaveThread(doSave);                                         \
         return rval;                                                    \
     }                                                                   \
@@ -1090,8 +1163,8 @@ public:
     size_t CLASS::CBNAME() {                                                    \
         size_t rval;                                                            \
         bool doSave = wxPyRestoreThread();                                      \
     size_t CLASS::CBNAME() {                                                    \
         size_t rval;                                                            \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME))                                     \
-            rval = m_myInst.callCallback(Py_BuildValue("()"));                  \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                  \
         else                                                                    \
             rval = PCLASS::CBNAME();                                            \
         wxPySaveThread(doSave);                                                 \
         else                                                                    \
             rval = PCLASS::CBNAME();                                            \
         wxPySaveThread(doSave);                                                 \
@@ -1112,10 +1185,10 @@ public:
     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
         wxDataFormat rval;                                                      \
         bool doSave = wxPyRestoreThread();                                      \
     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
         wxDataFormat rval;                                                      \
         bool doSave = wxPyRestoreThread();                                      \
-        if (m_myInst.findCallback(#CBNAME)) {                                   \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
             PyObject* ro;                                                       \
             wxDataFormat* ptr;                                                  \
             PyObject* ro;                                                       \
             wxDataFormat* ptr;                                                  \
-            ro = m_myInst.callCallbackObj(Py_BuildValue("(i)", a));             \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));             \
             if (ro) {                                                           \
                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxDataFormat_p"))     \
                     rval = *ptr;                                                \
             if (ro) {                                                           \
                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxDataFormat_p"))     \
                     rval = *ptr;                                                \
@@ -1141,9 +1214,9 @@ public:
 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)           \
     void CLASS::CBNAME(const Type& a) {                                 \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)           \
     void CLASS::CBNAME(const Type& a) {                                 \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)&a, #Type);      \
-            m_myInst.callCallback(Py_BuildValue("(O)", obj));           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));           \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
@@ -1165,9 +1238,9 @@ public:
 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                \
     void CLASS::CBNAME(Type& a) {                                       \
         bool doSave = wxPyRestoreThread();                              \
 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                \
     void CLASS::CBNAME(Type& a) {                                       \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)&a, #Type);      \
-            m_myInst.callCallback(Py_BuildValue("(O)", obj));           \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));           \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
@@ -1189,9 +1262,9 @@ public:
     bool CLASS::CBNAME(Type& a) {                                       \
         bool rv;                                                        \
         bool doSave = wxPyRestoreThread();                              \
     bool CLASS::CBNAME(Type& a) {                                       \
         bool rv;                                                        \
         bool doSave = wxPyRestoreThread();                              \
-        if (m_myInst.findCallback(#CBNAME)) {                           \
-            PyObject* obj = wxPyConstructObject((void*)&a, #Type);      \
-            rv = m_myInst.callCallback(Py_BuildValue("(O)", obj));      \
+        if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
+            PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
+            rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));      \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \
             Py_DECREF(obj);                                             \
         }                                                               \
         else                                                            \