Save the initial tstate during initialization

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

diff --git a/wxPython/src/helpers.h b/wxPython/src/helpers.h
index 3ad0d236a71dcddb10412805b7e1be8f0078531c..55f28dbc7c0db4e4f6c50bc3e0fa082be3f635d1 100644 (file)
--- a/wxPython/src/helpers.h
+++ b/wxPython/src/helpers.h
@@ -14,27 +14,17 @@
 #define __wxp_helpers__
 
 #include <wx/wx.h>
 #define __wxp_helpers__
 
 #include <wx/wx.h>

+#include <wx/geometry.h>

 
 

-
+//---------------------------------------------------------------------------
+#ifdef __WXMAC__  // avoid a bug in Carbon headers
+#define scalb scalbn
+#endif

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

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

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


@@ -62,6 +52,9 @@ void      wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
 PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
 long      wxPyGetWinHandle(wxWindow* win);
 
 PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
 long      wxPyGetWinHandle(wxWindow* win);
 

+void wxPy_ReinitStockObjects();
+
+

 //----------------------------------------------------------------------
 
 // if we want to handle threads and Python threads are available...
 //----------------------------------------------------------------------
 
 // if we want to handle threads and Python threads are available...


@@ -80,6 +73,8 @@ void           wxPyEndAllowThreads(PyThreadState* state);
 void wxPyBeginBlockThreads();
 void wxPyEndBlockThreads();
 
 void wxPyBeginBlockThreads();
 void wxPyEndBlockThreads();
 

+#define wxPyBLOCK_THREADS(stmt) wxPyBeginBlockThreads(); stmt; wxPyEndBlockThreads()
+

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


@@ -101,6 +96,9 @@ bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
 bool wxRect_helper(PyObject* source, wxRect** obj);
 bool wxColour_helper(PyObject* source, wxColour** obj);
 
 bool wxRect_helper(PyObject* source, wxRect** obj);
 bool wxColour_helper(PyObject* source, wxColour** obj);
 

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

 //----------------------------------------------------------------------
 // Other helpful stuff
 
 //----------------------------------------------------------------------
 // Other helpful stuff
 


@@ -109,8 +107,8 @@ bool wxColour_helper(PyObject* source, wxColour** obj);
      (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
 #endif
 
      (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
 #endif
 

-bool _2int_seq_helper(PyObject* source, int* i1, int* i2);
-bool _4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4);
+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* wxArrayString2PyList_helper(const wxArrayString& arr);


@@ -120,6 +118,21 @@ PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr);
 #define DECLARE_DEF_STRING(name)      static const wxString wxPy##name(wx##name)
 #define DECLARE_DEF_STRING2(name,val) static const wxString wxPy##name(val)
 
 #define DECLARE_DEF_STRING(name)      static const wxString wxPy##name(wx##name)
 #define DECLARE_DEF_STRING2(name,val) static const wxString wxPy##name(val)
 

+//----------------------------------------------------------------------
+// functions used by the DrawXXXList enhancements added to wxDC
+
+typedef bool (*wxPyDrawListOp_t)(wxDC& dc, PyObject* coords);
+PyObject* wxPyDrawXXXList(wxDC& dc, wxPyDrawListOp_t doDraw,
+                          PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes);
+bool wxPyDrawXXXPoint(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXLine(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXRectangle(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXEllipse(wxDC& dc, PyObject* coords);
+bool wxPyDrawXXXPolygon(wxDC& dc, PyObject* coords);
+
+PyObject* wxPyDrawTextList(wxDC& dc, PyObject* textList, PyObject* pyPoints,
+                           PyObject* foregroundList, PyObject* backgroundList);
+

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


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

+    bool GetCloned() const { return m_cloned; }

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


@@ -185,7 +199,7 @@ protected:
 class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
     DECLARE_ABSTRACT_CLASS(wxPyEvent)
 public:
 class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
     DECLARE_ABSTRACT_CLASS(wxPyEvent)
 public:

-    wxPyEvent(int id=0);
+    wxPyEvent(int winid=0, wxEventType commandType = wxEVT_NULL);

     wxPyEvent(const wxPyEvent& evt);
     ~wxPyEvent();
 
     wxPyEvent(const wxPyEvent& evt);
     ~wxPyEvent();
 


@@ -210,10 +224,12 @@ public:
 class wxPyClientData;
 class wxPyUserData;
 class wxPyOORClientData;
 class wxPyClientData;
 class wxPyUserData;
 class wxPyOORClientData;

+class wxPyCBInputStream;

 
 void wxPyClientData_dtor(wxPyClientData* self);
 void wxPyUserData_dtor(wxPyUserData* self);
 void wxPyOORClientData_dtor(wxPyOORClientData* self);
 
 void wxPyClientData_dtor(wxPyClientData* self);
 void wxPyUserData_dtor(wxPyUserData* self);
 void wxPyOORClientData_dtor(wxPyOORClientData* self);

+wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block);

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


@@ -268,6 +284,7 @@ struct wxPyCoreAPI {
     bool        (*p_wxRealPoint_helper)(PyObject* source, wxRealPoint** obj);
     bool        (*p_wxRect_helper)(PyObject* source, wxRect** obj);
     bool        (*p_wxColour_helper)(PyObject* source, wxColour** obj);
     bool        (*p_wxRealPoint_helper)(PyObject* source, wxRealPoint** obj);
     bool        (*p_wxRect_helper)(PyObject* source, wxRect** obj);
     bool        (*p_wxColour_helper)(PyObject* source, wxColour** obj);

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

 
     void        (*p_wxPyCBH_setCallbackInfo)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
     bool        (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
 
     void        (*p_wxPyCBH_setCallbackInfo)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
     bool        (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);


@@ -285,6 +302,9 @@ struct wxPyCoreAPI {
     void        (*p_wxPyClientData_dtor)(wxPyClientData*);
     void        (*p_wxPyUserData_dtor)(wxPyUserData*);
     void        (*p_wxPyOORClientData_dtor)(wxPyOORClientData*);
     void        (*p_wxPyClientData_dtor)(wxPyClientData*);
     void        (*p_wxPyUserData_dtor)(wxPyUserData*);
     void        (*p_wxPyOORClientData_dtor)(wxPyOORClientData*);

+
+    wxPyCBInputStream* (*p_wxPyCBInputStream_create)(PyObject *py, bool block);
+

 };
 
 #ifdef wxPyUSE_EXPORT
 };
 
 #ifdef wxPyUSE_EXPORT


@@ -399,31 +419,88 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------

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

 
 

-#define PYPRIVATE                                                       \
+// This is used in C++ classes that need to be able to make callback to
+// "overloaded" python methods
+
+#define PYPRIVATE                                                               \

     void _setCallbackInfo(PyObject* self, PyObject* _class, int incref=1) {     \
         wxPyCBH_setCallbackInfo(m_myInst, self, _class, incref);                \
     void _setCallbackInfo(PyObject* self, PyObject* _class, int incref=1) {     \
         wxPyCBH_setCallbackInfo(m_myInst, self, _class, incref);                \

-    }                                                                   \
+    }                                                                           \

     private: wxPyCallbackHelper m_myInst
 
     private: wxPyCallbackHelper m_myInst
 

+
+//---------------------------------------------------------------------------
+
+enum {
+    wxPYAPP_ASSERT_SUPPRESS  = 1,
+    wxPYAPP_ASSERT_EXCEPTION = 2,
+    wxPYAPP_ASSERT_DIALOG    = 4,
+    wxPYAPP_ASSERT_LOG       = 8
+};
+
+class wxPyApp: public wxApp
+{
+    DECLARE_ABSTRACT_CLASS(wxPyApp);
+
+public:
+    wxPyApp();
+    ~wxPyApp();
+    bool OnInit();
+    int  MainLoop();
+
+    int  GetAssertMode() { return m_assertMode; }
+    void SetAssertMode(int mode) { m_assertMode = mode; }
+
+    virtual bool OnInitGui();
+    virtual int OnExit();
+#ifdef __WXDEBUG__
+    virtual void OnAssert(const wxChar *file,
+                          int line,
+                          const wxChar *cond,
+                          const wxChar *msg);
+#endif
+    // virtual int FilterEvent(wxEvent& event); // This one too????
+
+
+    static bool GetMacSupportPCMenuShortcuts();
+    static long GetMacAboutMenuItemId();
+    static long GetMacPreferencesMenuItemId();
+    static long GetMacExitMenuItemId();
+    static wxString GetMacHelpMenuTitleName();
+
+    static void SetMacSupportPCMenuShortcuts(bool val);
+    static void SetMacAboutMenuItemId(long val);
+    static void SetMacPreferencesMenuItemId(long val);
+    static void SetMacExitMenuItemId(long val);
+    static void SetMacHelpMenuTitleName(const wxString& val);
+
+
+    PYPRIVATE;
+    int m_assertMode;
+};
+
+extern wxPyApp *wxPythonApp;
+
+
+//----------------------------------------------------------------------
+// These macros are used to implement the virtual methods that should
+// redirect to a Python method if one exists.  The names designate the
+// return type, if any, as well as any parameter types.

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

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

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

-        wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                                        \

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

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

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


@@ -435,7 +512,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
     bool CBNAME(int a, int b);                                  \
 
 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
     bool CBNAME(int a, int b);                                  \

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

 
 
 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
 
 
 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \


@@ -455,9 +532,30 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

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

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

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

 
 
 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
 
 
 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \


@@ -476,9 +574,30 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

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

 #define DEC_PYCALLBACK_VOID_INT4(CBNAME)                                \
     void CBNAME(int a, int b, int c, int d);                            \
 #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 base_##CBNAME(int a, int b, int c, int d)

 
 
 #define IMP_PYCALLBACK_VOID_INT4(CLASS, PCLASS, CBNAME)                 \
 
 
 #define IMP_PYCALLBACK_VOID_INT4(CLASS, PCLASS, CBNAME)                 \


@@ -498,7 +617,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 #define DEC_PYCALLBACK_VOID_INT5(CBNAME)                                \
     void CBNAME(int a, int b, int c, int d, int e);                     \
 //---------------------------------------------------------------------------
 #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 base_##CBNAME(int a, int b, int c, int d, int e)

 
 
 #define IMP_PYCALLBACK_VOID_INT5(CLASS, PCLASS, CBNAME)                 \
 
 
 #define IMP_PYCALLBACK_VOID_INT5(CLASS, PCLASS, CBNAME)                 \


@@ -519,7 +638,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_VOID_INTPINTP_const(CBNAME)                              \
     void CBNAME(int* a, int* b) const;                                          \
 
 #define DEC_PYCALLBACK_VOID_INTPINTP_const(CBNAME)                              \
     void CBNAME(int* a, int* b) const;                                          \

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

 
 
 #define IMP_PYCALLBACK_VOID_INTPINTP_const(CLASS, PCLASS, CBNAME)               \
 
 
 #define IMP_PYCALLBACK_VOID_INTPINTP_const(CLASS, PCLASS, CBNAME)               \


@@ -561,7 +680,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_SIZE_const(CBNAME)                                       \
     wxSize CBNAME() const;                                                      \
 
 #define DEC_PYCALLBACK_SIZE_const(CBNAME)                                       \
     wxSize CBNAME() const;                                                      \

-    wxSize base_##CBNAME() const;
+    wxSize base_##CBNAME() const

 
 
 #define IMP_PYCALLBACK_SIZE_const(CLASS, PCLASS, CBNAME)                        \
 
 
 #define IMP_PYCALLBACK_SIZE_const(CLASS, PCLASS, CBNAME)                        \


@@ -603,9 +722,31 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

+#define DEC_PYCALLBACK_BOOL_BOOL(CBNAME)                         \
+    bool CBNAME(bool a);                                         \
+    bool base_##CBNAME(bool a)
+
+
+#define IMP_PYCALLBACK_BOOL_BOOL(CLASS, PCLASS, CBNAME)                 \
+    bool CLASS::CBNAME(bool a) {                                        \
+        bool rval=FALSE, found;                                         \
+        wxPyBeginBlockThreads();                                        \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
+        wxPyEndBlockThreads();                                          \
+        if (! found)                                                    \
+            rval = PCLASS::CBNAME(a);                                   \
+        return rval;                                                    \
+    }                                                                   \
+    bool CLASS::base_##CBNAME(bool a) {                                 \
+        return PCLASS::CBNAME(a);                                       \
+    }
+
+//---------------------------------------------------------------------------
+

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

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

 
 
 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
 
 
 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \


@@ -626,7 +767,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \

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

 
 
 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
 
 
 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \


@@ -645,19 +786,19 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__DC(CBNAME)                      \
     void CBNAME(wxDC& a);                               \
 
 #define DEC_PYCALLBACK__DC(CBNAME)                      \
     void CBNAME(wxDC& a);                               \

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

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

-        wxPyBeginBlockThreads();                    \
+        wxPyBeginBlockThreads();                                        \

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

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

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


@@ -671,7 +812,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \

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

 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \


@@ -695,7 +836,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
     void CBNAME(wxDC& a, bool b);                               \
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
     void CBNAME(wxDC& a, bool b);                               \

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

 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \


@@ -719,7 +860,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
     void CBNAME(double a, double b);                    \
 
 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
     void CBNAME(double a, double b);                    \

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

 
 
 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
 
 
 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \


@@ -740,7 +881,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
     void CBNAME(double a, double b, int c, int d);              \
 
 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
     void CBNAME(double a, double b, int c, int d);              \

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

 
 
 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 
 
 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \


@@ -762,7 +903,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME)                                      \
     void CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 
 #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 base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f)

 
 
 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
 
 
 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \


@@ -786,7 +927,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 
 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \

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

 
 
 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
 
 
 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \


@@ -812,7 +953,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
     void CBNAME(bool a, double b, double c, int d, int e);              \
 
 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
     void CBNAME(bool a, double b, double c, int d, int e);              \

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

 
 
 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 
 
 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \


@@ -834,7 +975,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__DC4DBL(CBNAME)                                          \
     void CBNAME(wxDC& a, double b, double c, double d, double e);               \
 
 #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 base_##CBNAME(wxDC& a, double b, double c, double d, double e)

 
 
 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
 
 
 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \


@@ -858,7 +999,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \
 
 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
     void CBNAME(wxDC& a, bool b);                       \

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

 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                           \
 
 
 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                           \


@@ -882,7 +1023,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \
 
 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \

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

 
 
 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 
 
 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \


@@ -908,7 +1049,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \
 
 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \

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

 
 
 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 
 
 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \


@@ -933,7 +1074,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
     void CBNAME(double a, double b, int c);             \
 
 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
     void CBNAME(double a, double b, int c);             \

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

 
 
 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \
 
 
 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \


@@ -954,7 +1095,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
     void CBNAME(bool a, double b, double c, int d);             \
 
 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
     void CBNAME(bool a, double b, double c, int d);             \

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

 
 
 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
 
 
 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \


@@ -976,7 +1117,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
     void CBNAME(const wxString& a);                     \
 
 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
     void CBNAME(const wxString& a);                     \

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

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


@@ -999,7 +1140,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
     bool CBNAME(const wxString& a);                     \
 
 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
     bool CBNAME(const wxString& a);                     \

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

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


@@ -1023,7 +1164,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \

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

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


@@ -1041,7 +1182,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME)                               \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME)                               \

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

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


@@ -1063,8 +1204,35 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

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

 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME)                            \
 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME)                            \

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

 
 #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME)             \
     wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
 
 #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME)             \
     wxString CLASS::CBNAME(const wxString& a,int b)  {                          \


@@ -1088,7 +1256,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME)              \
     bool CBNAME(const wxString& a, const wxString& b);        \
 
 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME)              \
     bool CBNAME(const wxString& a, const wxString& b);        \

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

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


@@ -1115,7 +1283,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
     wxString CBNAME();                                  \
 
 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
     wxString CBNAME();                                  \

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

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


@@ -1141,8 +1309,36 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

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

 #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
 #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \

-    wxString CBNAME();
+    wxString CBNAME()

 
 #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
     wxString CLASS::CBNAME() {                                                  \
 
 #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
     wxString CLASS::CBNAME() {                                                  \


@@ -1162,8 +1358,29 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

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

 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \
 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \

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

 
 
 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
 
 
 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \


@@ -1171,7 +1388,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
         bool rval=FALSE;                                                        \
         wxPyBeginBlockThreads();                                                \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
         bool rval=FALSE;                                                        \
         wxPyBeginBlockThreads();                                                \
         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \

-            PyObject* obj = wxPyConstructObject((void*)&a, "wxHtmlTag", 0);     \
+            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);                                                     \
         }                                                                       \


@@ -1183,14 +1400,14 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__CELLINTINT(CBNAME)                                      \
     void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);                        \
 
 #define DEC_PYCALLBACK__CELLINTINT(CBNAME)                                      \
     void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);                        \

-    void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);
+    void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y)

 
 #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 
 #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
+            PyObject* obj = wxPyConstructObject((void*)cell, wxT("wxHtmlCell"), 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);                                                     \
         }                                                                       \


@@ -1207,15 +1424,15 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__CELLINTINTME(CBNAME)                                    \
     void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e); \
 
 #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);
+    void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e)

 
 #define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 
 #define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
-            PyObject* o2  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0);  \
+            PyObject* obj = wxPyConstructObject((void*)cell, wxT("wxHtmlCell"), 0);  \
+            PyObject* o2  = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0);  \

             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OiiO)",obj,x,y,o2));  \
             Py_DECREF(obj);                                                     \
             Py_DECREF(o2);                                                      \
             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OiiO)",obj,x,y,o2));  \
             Py_DECREF(obj);                                                     \
             Py_DECREF(o2);                                                      \


@@ -1233,7 +1450,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK___pure(CBNAME)                         \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK___pure(CBNAME)                         \

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

 
 
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
 
 
 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \


@@ -1247,7 +1464,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_wxSize__pure(CBNAME)                         \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_wxSize__pure(CBNAME)                         \

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

 
 
 #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME)                      \
 
 
 #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME)                      \


@@ -1286,7 +1503,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME)                      \
     bool CBNAME(wxWindow* a);                                  \
 
 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME)                      \
     bool CBNAME(wxWindow* a);                                  \

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

 
 
 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                        \
 
 
 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                        \


@@ -1310,9 +1527,61 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

+#define DEC_PYCALLBACK_BOOL_WXWINDC(CBNAME)                             \
+    bool CBNAME(wxWindow* a, wxDC& b);                                  \
+    bool base_##CBNAME(wxWindow* a, wxDC& b)
+
+
+#define IMP_PYCALLBACK_BOOL_WXWINDC(CLASS, PCLASS, CBNAME)                        \
+    bool CLASS::CBNAME(wxWindow* a, wxDC& b) {                                  \
+        bool rval=FALSE;                                                        \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* win = wxPyMake_wxObject(a);                               \
+            PyObject* dc  = wxPyMake_wxObject(&b);                              \
+            rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));\
+            Py_DECREF(win);                                                     \
+            Py_DECREF(dc);                                                      \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            rval = PCLASS::CBNAME(a, b);                                        \
+        return rval;                                                            \
+    }                                                                           \
+    bool CLASS::base_##CBNAME(wxWindow* a, wxDC& b) {                           \
+        return PCLASS::CBNAME(a, b);                                            \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_VOID_WXWINBASE(CBNAME)                      \
+    void CBNAME(wxWindowBase* a);                                  \
+    void base_##CBNAME(wxWindowBase* a)
+
+
+#define IMP_PYCALLBACK_VOID_WXWINBASE(CLASS, PCLASS, CBNAME)                    \
+    void CLASS::CBNAME(wxWindowBase* a) {                                       \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* obj = wxPyMake_wxObject(a);                               \
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
+            Py_DECREF(obj);                                                     \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        if (! found)                                                            \
+            PCLASS::CBNAME(a);                                                  \
+    }                                                                           \
+    void CLASS::base_##CBNAME(wxWindowBase* a) {                                \
+        PCLASS::CBNAME(a);                                                      \
+    }
+
+//---------------------------------------------------------------------------
+

 #define DEC_PYCALLBACK_BOOL_(CBNAME)                      \
     bool CBNAME();                                        \
 #define DEC_PYCALLBACK_BOOL_(CBNAME)                      \
     bool CBNAME();                                        \

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

 
 
 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                             \
 
 
 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                             \


@@ -1335,7 +1604,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_const(CBNAME)                       \
     bool CBNAME() const;                                        \
 
 #define DEC_PYCALLBACK_BOOL_const(CBNAME)                       \
     bool CBNAME() const;                                        \

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

 
 
 #define IMP_PYCALLBACK_BOOL_const(CLASS, PCLASS, CBNAME)                        \
 
 
 #define IMP_PYCALLBACK_BOOL_const(CLASS, PCLASS, CBNAME)                        \


@@ -1358,7 +1627,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_DR_2WXCDR(CBNAME)                                \
     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);        \
 
 #define DEC_PYCALLBACK_DR_2WXCDR(CBNAME)                                \
     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);        \

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

 
 
 #define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                         \
 
 
 #define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                         \


@@ -1380,7 +1649,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \

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

 
 #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
     wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
 
 #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
     wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \


@@ -1407,7 +1676,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
     bool CBNAME(wxDragResult a);                        \
 
 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
     bool CBNAME(wxDragResult a);                        \

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

 
 
 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \
 
 
 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \


@@ -1429,7 +1698,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME)   \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME)   \

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

 
 
 #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)            \
 
 
 #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)            \


@@ -1445,7 +1714,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \
 //---------------------------------------------------------------------------
 
 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \

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

 
 #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
 
 #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \


@@ -1464,7 +1733,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_SIZET_(CBNAME)                  \
     size_t CBNAME();                                   \
 
 #define DEC_PYCALLBACK_SIZET_(CBNAME)                  \
     size_t CBNAME();                                   \

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

 
 
 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
 
 
 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \


@@ -1487,7 +1756,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME)                                    \
     wxDataFormat  CBNAME(size_t a);                                             \
 
 #define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME)                                    \
     wxDataFormat  CBNAME(size_t a);                                             \

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

 
 
 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
 
 
 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \


@@ -1518,7 +1787,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
     void CBNAME(const Type& a);                         \
 
 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
     void CBNAME(const Type& a);                         \

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

 
 
 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
 
 
 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \


@@ -1526,7 +1795,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)&a, #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);                                                     \
         }                                                                       \


@@ -1543,7 +1812,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
     void CBNAME(Type& a);                          \
 
 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
     void CBNAME(Type& a);                          \

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

 
 
 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
 
 
 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \


@@ -1551,7 +1820,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)&a, #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);                                                     \
         }                                                                       \


@@ -1567,7 +1836,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
     bool CBNAME(Type& a);                               \
 
 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
     bool CBNAME(Type& a);                               \

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

 
 
 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
 
 
 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \


@@ -1576,7 +1845,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
         bool found;                                                             \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \

-            PyObject* obj = wxPyConstructObject((void*)&a, #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);                                                     \
         }                                                                       \


@@ -1591,9 +1860,28 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

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

 #define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME)                                  \
     wxString CBNAME(long a, long b) const;                                      \
 #define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME)                                  \
     wxString CBNAME(long a, long b) const;                                      \

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

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


@@ -1621,7 +1909,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_INT_LONG(CBNAME)                                         \
     int CBNAME(long a) const;                                                   \
 
 #define DEC_PYCALLBACK_INT_LONG(CBNAME)                                         \
     int CBNAME(long a) const;                                                   \

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

 
 
 #define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME)                          \
 
 
 #define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME)                          \


@@ -1651,7 +1939,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_LISTATTR_LONG(CBNAME)                                    \
     wxListItemAttr*  CBNAME(long a) const;                                      \
 
 #define DEC_PYCALLBACK_LISTATTR_LONG(CBNAME)                                    \
     wxListItemAttr*  CBNAME(long a) const;                                      \

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

 
 
 #define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME)                     \
 
 
 #define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME)                     \


@@ -1674,7 +1962,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
     }                                                                           \
             rval = PCLASS::CBNAME(a);                                           \
         return rval;                                                            \
     }                                                                           \

-    wxListItemAttr *CLASS::base_##CBNAME(long a) {                              \
+    wxListItemAttr *CLASS::base_##CBNAME(long a) const {                        \

         return PCLASS::CBNAME(a);                                               \
     }
 
         return PCLASS::CBNAME(a);                                               \
     }
 


@@ -1682,7 +1970,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 #define DEC_PYCALLBACK_BOOL_ME(CBNAME)                                          \
     bool CBNAME(wxMouseEvent& e);                                               \
 
 #define DEC_PYCALLBACK_BOOL_ME(CBNAME)                                          \
     bool CBNAME(wxMouseEvent& e);                                               \

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

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


@@ -1691,7 +1979,7 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \
         wxPyBeginBlockThreads();                                                \
         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
             PyObject* ro;                                                       \

-            PyObject* obj  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0); \
+            PyObject* obj  = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0); \

             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj));   \
             if (ro) {                                                           \
                 rval = PyInt_AsLong(ro);                                        \
             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj));   \
             if (ro) {                                                           \
                 rval = PyInt_AsLong(ro);                                        \


@@ -1711,4 +1999,268 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

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

 #endif
 #endif