wxPython/src/helpers.h

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        helpers.h
   3 // Purpose:     Helper functions/classes for the wxPython extenaion module
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7/1/97
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifndef __wxp_helpers__
  14 #define __wxp_helpers__
  15
  16 #include <wx/wx.h>
  17
  18
  19 //---------------------------------------------------------------------------
  20
  21 typedef unsigned char byte;
  22
  23
  24 class wxPyApp: public wxApp
  25 {
  26 public:
  27     wxPyApp();
  28     ~wxPyApp();
  29     bool OnInit();
  30     int  MainLoop();
  31 };
  32
  33 extern wxPyApp *wxPythonApp;
  34
  35 //----------------------------------------------------------------------
  36
  37 void      __wxPreStart();
  38 PyObject* __wxStart(PyObject*, PyObject* args);
  39 void      __wxCleanup();
  40
  41 //extern PyObject* wxPython_dict;
  42 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
  43
  44 void wxPyEventThunker(wxObject*, wxEvent& event);
  45
  46 PyObject* wxPyConstructObject(void* ptr,
  47                               const wxString& className,
  48                               int setThisOwn=0);
  49 PyObject* wxPyConstructObject(void* ptr,
  50                               const wxString& className,
  51                               PyObject* klass,
  52                               int setThisOwn=0);
  53
  54 PyObject* wx2PyString(const wxString& src);
  55 wxString  Py2wxString(PyObject* source);
  56
  57 PyObject* wxPyClassExists(const wxString& className);
  58 PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler=TRUE);
  59 PyObject* wxPyMake_wxSizer(wxSizer* source);
  60 void      wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
  61
  62 PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
  63 long      wxPyGetWinHandle(wxWindow* win);
  64
  65 //----------------------------------------------------------------------
  66
  67 // if we want to handle threads and Python threads are available...
  68 #if defined(WXP_USE_THREAD) && defined(WITH_THREAD)
  69 #define WXP_WITH_THREAD
  70 #else  // no Python threads...
  71 #undef WXP_WITH_THREAD
  72 #endif
  73
  74
  75 // For Python --> C++
  76 PyThreadState* wxPyBeginAllowThreads();
  77 void           wxPyEndAllowThreads(PyThreadState* state);
  78
  79 // For C++ --> Python
  80 void wxPyBeginBlockThreads();
  81 void wxPyEndBlockThreads();
  82
  83 //----------------------------------------------------------------------
  84 // These are helpers used by the typemaps
  85
  86 wxString* wxString_in_helper(PyObject* source);
  87
  88 byte* byte_LIST_helper(PyObject* source);
  89 int* int_LIST_helper(PyObject* source);
  90 long* long_LIST_helper(PyObject* source);
  91 char** string_LIST_helper(PyObject* source);
  92 wxPoint* wxPoint_LIST_helper(PyObject* source, int* npoints);
  93 wxBitmap** wxBitmap_LIST_helper(PyObject* source);
  94 wxString* wxString_LIST_helper(PyObject* source);
  95 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
  96 wxPen** wxPen_LIST_helper(PyObject* source);
  97
  98 bool wxSize_helper(PyObject* source, wxSize** obj);
  99 bool wxPoint_helper(PyObject* source, wxPoint** obj);
 100 bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
 101 bool wxRect_helper(PyObject* source, wxRect** obj);
 102 bool wxColour_helper(PyObject* source, wxColour** obj);
 103
 104 //----------------------------------------------------------------------
 105 // Other helpful stuff
 106
 107 #if PYTHON_API_VERSION < 1009
 108 #define PySequence_Fast_GET_ITEM(o, i) \
 109      (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
 110 #endif
 111
 112 bool _2int_seq_helper(PyObject* source, int* i1, int* i2);
 113 bool _4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4);
 114
 115
 116 PyObject* wxArrayString2PyList_helper(const wxArrayString& arr);
 117 PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr);
 118
 119 #define RETURN_NONE()                 { Py_INCREF(Py_None); return Py_None; }
 120 #define DECLARE_DEF_STRING(name)      static const wxString wxPy##name(wx##name)
 121 #define DECLARE_DEF_STRING2(name,val) static const wxString wxPy##name(val)
 122
 123 //----------------------------------------------------------------------
 124
 125 #ifndef SWIGCODE
 126 extern "C" void SWIG_MakePtr(char *, void *, char *);
 127 extern "C" char *SWIG_GetPtr(char *, void **, char *);
 128 extern "C" char *SWIG_GetPtrObj(PyObject *obj, void **ptr, char *type);
 129 #endif
 130
 131
 132 #ifdef _MSC_VER
 133 # pragma warning(disable:4800)
 134 # pragma warning(disable:4190)
 135 #endif
 136
 137 //----------------------------------------------------------------------
 138
 139 class wxPyCallback : public wxObject {
 140     DECLARE_ABSTRACT_CLASS(wxPyCallback);
 141 public:
 142     wxPyCallback(PyObject* func);
 143     wxPyCallback(const wxPyCallback& other);
 144     ~wxPyCallback();
 145
 146     void EventThunker(wxEvent& event);
 147
 148     PyObject*   m_func;
 149 };
 150
 151 //---------------------------------------------------------------------------
 152
 153 class wxPyTimer : public wxTimer {
 154 public:
 155     wxPyTimer(PyObject* callback);
 156     ~wxPyTimer();
 157
 158     void        Notify();
 159
 160 private:
 161     PyObject*   func;
 162 };
 163
 164 //---------------------------------------------------------------------------
 165 //---------------------------------------------------------------------------
 166 // These Event classes can be derived from in Python and passed through the
 167 // event system without loosing anything.  They do this by keeping a reference
 168 // to themselves and some special case handling in wxPyCallback::EventThunker.
 169
 170
 171 class wxPyEvtSelfRef {
 172 public:
 173     wxPyEvtSelfRef();
 174     ~wxPyEvtSelfRef();
 175
 176     void SetSelf(PyObject* self, bool clone=FALSE);
 177     PyObject* GetSelf() const;
 178
 179 protected:
 180     PyObject*   m_self;
 181     bool        m_cloned;
 182 };
 183
 184
 185 class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
 186     DECLARE_ABSTRACT_CLASS(wxPyEvent)
 187 public:
 188     wxPyEvent(int id=0);
 189     wxPyEvent(const wxPyEvent& evt);
 190     ~wxPyEvent();
 191
 192     virtual wxEvent* Clone() const { return new wxPyEvent(*this); }
 193 };
 194
 195
 196 class wxPyCommandEvent : public wxCommandEvent, public wxPyEvtSelfRef {
 197     DECLARE_ABSTRACT_CLASS(wxPyCommandEvent)
 198 public:
 199     wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0);
 200     wxPyCommandEvent(const wxPyCommandEvent& evt);
 201     ~wxPyCommandEvent();
 202
 203     virtual wxEvent* Clone() const { return new wxPyCommandEvent(*this); }
 204 };
 205
 206
 207
 208 //----------------------------------------------------------------------
 209 // Forward decalre a few things used in the exported API
 210 class wxPyClientData;
 211 class wxPyUserData;
 212 class wxPyOORClientData;
 213
 214 void wxPyClientData_dtor(wxPyClientData* self);
 215 void wxPyUserData_dtor(wxPyUserData* self);
 216 void wxPyOORClientData_dtor(wxPyOORClientData* self);
 217
 218
 219 //---------------------------------------------------------------------------
 220 // Export a C API in a struct.  Other modules will be able to load this from
 221 // the wxc module and will then have safe access to these functions, even if
 222 // in another shared library.
 223
 224 class wxPyCallbackHelper;
 225
 226 struct wxPyCoreAPI {
 227
 228     void        (*p_SWIG_MakePtr)(char*, void*, char*);
 229     char*       (*p_SWIG_GetPtr)(char*, void**, char*);
 230     char*       (*p_SWIG_GetPtrObj)(PyObject*, void**, char*);
 231     void        (*p_SWIG_RegisterMapping)(char*, char*, void *(*cast)(void *));
 232     void        (*p_SWIG_addvarlink)(PyObject*, char*, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p));
 233     PyObject*   (*p_SWIG_newvarlink)(void);
 234
 235     PyThreadState* (*p_wxPyBeginAllowThreads)();
 236     void           (*p_wxPyEndAllowThreads)(PyThreadState* state);
 237     void        (*p_wxPyBeginBlockThreads)();
 238     void        (*p_wxPyEndBlockThreads)();
 239
 240     PyObject*   (*p_wxPyConstructObject)(void *, const wxString&, int);
 241     PyObject*   (*p_wxPy_ConvertList)(wxListBase* list, const char* className);
 242
 243     wxString*   (*p_wxString_in_helper)(PyObject* source);
 244     wxString    (*p_Py2wxString)(PyObject* source);
 245     PyObject*   (*p_wx2PyString)(const wxString& src);
 246
 247     byte*       (*p_byte_LIST_helper)(PyObject* source);
 248     int*        (*p_int_LIST_helper)(PyObject* source);
 249     long*       (*p_long_LIST_helper)(PyObject* source);
 250     char**      (*p_string_LIST_helper)(PyObject* source);
 251     wxPoint*    (*p_wxPoint_LIST_helper)(PyObject* source, int* npoints);
 252     wxBitmap**  (*p_wxBitmap_LIST_helper)(PyObject* source);
 253     wxString*   (*p_wxString_LIST_helper)(PyObject* source);
 254     wxAcceleratorEntry*   (*p_wxAcceleratorEntry_LIST_helper)(PyObject* source);
 255
 256     bool        (*p_wxSize_helper)(PyObject* source, wxSize** obj);
 257     bool        (*p_wxPoint_helper)(PyObject* source, wxPoint** obj);
 258     bool        (*p_wxRealPoint_helper)(PyObject* source, wxRealPoint** obj);
 259     bool        (*p_wxRect_helper)(PyObject* source, wxRect** obj);
 260     bool        (*p_wxColour_helper)(PyObject* source, wxColour** obj);
 261
 262     void        (*p_wxPyCBH_setCallbackInfo)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
 263     bool        (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
 264     int         (*p_wxPyCBH_callCallback)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 265     PyObject*   (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 266     void        (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
 267
 268     PyObject*   (*p_wxPyClassExists)(const wxString& className);
 269     PyObject*   (*p_wxPyMake_wxObject)(wxObject* source, bool checkEvtHandler);
 270     PyObject*   (*p_wxPyMake_wxSizer)(wxSizer* source);
 271     void        (*p_wxPyPtrTypeMap_Add)(const char* commonName, const char* ptrName);
 272     PyObject*   (*p_wxArrayString2PyList_helper)(const wxArrayString& arr);
 273     PyObject*   (*p_wxArrayInt2PyList_helper)(const wxArrayInt& arr);
 274
 275     void        (*p_wxPyClientData_dtor)(wxPyClientData*);
 276     void        (*p_wxPyUserData_dtor)(wxPyUserData*);
 277     void        (*p_wxPyOORClientData_dtor)(wxPyOORClientData*);
 278 };
 279
 280 #ifdef wxPyUSE_EXPORT
 281 static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;  // Each module needs one, but doesn't have to use it.
 282 #endif
 283
 284
 285 //---------------------------------------------------------------------------
 286
 287
 288 class wxPyUserData : public wxObject {
 289 public:
 290     wxPyUserData(PyObject* obj) {
 291         m_obj = obj;
 292         Py_INCREF(m_obj);
 293     }
 294
 295     ~wxPyUserData() {
 296 #ifdef wxPyUSE_EXPORT
 297         wxPyCoreAPIPtr->p_wxPyUserData_dtor(this);
 298 #else
 299         wxPyUserData_dtor(this);
 300 #endif
 301     }
 302     PyObject* m_obj;
 303 };
 304
 305
 306 class wxPyClientData : public wxClientData {
 307 public:
 308     wxPyClientData(PyObject* obj) {
 309         m_obj = obj;
 310         Py_INCREF(m_obj);
 311     }
 312
 313     ~wxPyClientData() {
 314 #ifdef wxPyUSE_EXPORT
 315         wxPyCoreAPIPtr->p_wxPyClientData_dtor(this);
 316 #else
 317         wxPyClientData_dtor(this);
 318 #endif
 319     }
 320     PyObject* m_obj;
 321 };
 322
 323
 324 class wxPyOORClientData : public wxPyClientData {
 325 public:
 326     wxPyOORClientData(PyObject* obj)
 327         : wxPyClientData(obj) {}
 328
 329     ~wxPyOORClientData() {
 330 #ifdef wxPyUSE_EXPORT
 331         wxPyCoreAPIPtr->p_wxPyOORClientData_dtor(this);
 332 #else
 333         wxPyOORClientData_dtor(this);
 334 #endif
 335     }
 336 };
 337
 338 //---------------------------------------------------------------------------
 339 // This class holds an instance of a Python Shadow Class object and assists
 340 // with looking up and invoking Python callback methods from C++ virtual
 341 // method redirections.  For all classes which have virtuals which should be
 342 // overridable in wxPython, a new subclass is created that contains a
 343 // wxPyCallbackHelper.
 344 //
 345
 346 class wxPyCallbackHelper {
 347 public:
 348     wxPyCallbackHelper(const wxPyCallbackHelper& other);
 349
 350     wxPyCallbackHelper() {
 351         m_class = NULL;
 352         m_self = NULL;
 353         m_lastFound = NULL;
 354         m_incRef = FALSE;
 355     }
 356
 357     ~wxPyCallbackHelper() {
 358 #ifdef wxPyUSE_EXPORT
 359         wxPyCoreAPIPtr->p_wxPyCBH_delete(this);
 360 #else
 361         wxPyCBH_delete(this);
 362 #endif
 363     }
 364
 365     void        setSelf(PyObject* self, PyObject* klass, int incref=TRUE);
 366     bool        findCallback(const char* name) const;
 367     int         callCallback(PyObject* argTuple) const;
 368     PyObject*   callCallbackObj(PyObject* argTuple) const;
 369
 370 private:
 371     PyObject*   m_self;
 372     PyObject*   m_class;
 373     PyObject*   m_lastFound;
 374     int         m_incRef;
 375
 376     friend      void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 377 };
 378
 379
 380 void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
 381 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name);
 382 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 383 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 384 void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 385
 386
 387
 388
 389 //---------------------------------------------------------------------------
 390 // These macros are used to implement the virtual methods that should
 391 // redirect to a Python method if one exists.  The names designate the
 392 // return type, if any, as well as any parameter types.
 393 //---------------------------------------------------------------------------
 394
 395 #define PYPRIVATE                                                       \
 396     void _setCallbackInfo(PyObject* self, PyObject* _class, int incref=1) {     \
 397         wxPyCBH_setCallbackInfo(m_myInst, self, _class, incref);                \
 398     }                                                                   \
 399     private: wxPyCallbackHelper m_myInst
 400
 401 //---------------------------------------------------------------------------
 402
 403 #define DEC_PYCALLBACK__(CBNAME)                        \
 404     void CBNAME();                                      \
 405     void base_##CBNAME();
 406
 407
 408 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)                         \
 409     void CLASS::CBNAME() {                                              \
 410         bool found;                                                     \
 411         wxPyBeginBlockThreads();                    \
 412         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 413             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));        \
 414         wxPyEndBlockThreads();                                     \
 415         if (! found)                                                    \
 416             PCLASS::CBNAME();                                           \
 417     }                                                                   \
 418     void CLASS::base_##CBNAME() {                                       \
 419         PCLASS::CBNAME();                                               \
 420     }
 421
 422 //---------------------------------------------------------------------------
 423
 424 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
 425     bool CBNAME(int a, int b);                                  \
 426     bool base_##CBNAME(int a, int b);
 427
 428
 429 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
 430     bool CLASS::CBNAME(int a, int b) {                                  \
 431         bool rval=FALSE, found;                                         \
 432         wxPyBeginBlockThreads();                    \
 433         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 434             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \
 435         wxPyEndBlockThreads();                                     \
 436         if (! found)                                                    \
 437             rval = PCLASS::CBNAME(a,b);                                 \
 438         return rval;                                                    \
 439     }                                                                   \
 440     bool CLASS::base_##CBNAME(int a, int b) {                           \
 441         return PCLASS::CBNAME(a,b);                                     \
 442     }
 443
 444 //---------------------------------------------------------------------------
 445
 446 #define DEC_PYCALLBACK_VOID_INTINT(CBNAME)                      \
 447     void CBNAME(int a, int b);                                  \
 448     void base_##CBNAME(int a, int b);
 449
 450
 451 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
 452     void CLASS::CBNAME(int a, int b) {                                  \
 453         bool found;                                                     \
 454         wxPyBeginBlockThreads();                    \
 455         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 456             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));  \
 457         wxPyEndBlockThreads();                                     \
 458         if (! found)                                                    \
 459             PCLASS::CBNAME(a,b);                                        \
 460     }                                                                   \
 461     void CLASS::base_##CBNAME(int a, int b) {                           \
 462         PCLASS::CBNAME(a,b);                                            \
 463     }
 464
 465 //---------------------------------------------------------------------------
 466
 467 #define DEC_PYCALLBACK_BOOL_INT(CBNAME)                         \
 468     bool CBNAME(int a);                                         \
 469     bool base_##CBNAME(int a);
 470
 471
 472 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
 473     bool CLASS::CBNAME(int a) {                                         \
 474         bool rval=FALSE, found;                                         \
 475         wxPyBeginBlockThreads();                    \
 476         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 477             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
 478         wxPyEndBlockThreads();                                     \
 479         if (! found)                                                    \
 480             rval = PCLASS::CBNAME(a);                                   \
 481         return rval;                                                    \
 482     }                                                                   \
 483     bool CLASS::base_##CBNAME(int a) {                                  \
 484         return PCLASS::CBNAME(a);                                       \
 485     }
 486
 487 //---------------------------------------------------------------------------
 488
 489 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \
 490     bool CBNAME(int a);
 491
 492
 493 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
 494     bool CLASS::CBNAME(int a) {                                         \
 495         bool rval=FALSE;                                                \
 496         wxPyBeginBlockThreads();                    \
 497         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
 498             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
 499         else rval = FALSE;                                              \
 500         wxPyEndBlockThreads();                                     \
 501         return rval;                                                    \
 502     }
 503
 504
 505 //---------------------------------------------------------------------------
 506
 507 #define DEC_PYCALLBACK__DC(CBNAME)                      \
 508     void CBNAME(wxDC& a);                               \
 509     void base_##CBNAME(wxDC& a);
 510
 511
 512 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)                       \
 513     void CLASS::CBNAME(wxDC& a) {                                       \
 514         bool found;                                                     \
 515         wxPyBeginBlockThreads();                    \
 516         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
 517             PyObject* obj = wxPyMake_wxObject(&a);                      \
 518             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));  \
 519             Py_DECREF(obj);                                             \
 520         }                                                               \
 521         wxPyEndBlockThreads();                                     \
 522         if (! found)                                                    \
 523             PCLASS::CBNAME(a);                                          \
 524     }                                                                   \
 525     void CLASS::base_##CBNAME(wxDC& a) {                                \
 526         PCLASS::CBNAME(a);                                              \
 527     }
 528
 529
 530
 531 //---------------------------------------------------------------------------
 532
 533 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 534     void CBNAME(wxDC& a, bool b);                       \
 535     void base_##CBNAME(wxDC& a, bool b);
 536
 537
 538 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 539     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 540         bool found;                                                     \
 541         wxPyBeginBlockThreads();                    \
 542         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
 543             PyObject* obj = wxPyMake_wxObject(&a);                      \
 544             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
 545             Py_DECREF(obj);                                             \
 546         }                                                               \
 547         wxPyEndBlockThreads();                                     \
 548         if (! found)                                                    \
 549             PCLASS::CBNAME(a, b);                                       \
 550     }                                                                   \
 551     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 552         PCLASS::CBNAME(a, b);                                           \
 553     }
 554
 555 //---------------------------------------------------------------------------
 556
 557 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
 558     void CBNAME(wxDC& a, bool b);                               \
 559     void base_##CBNAME(wxDC& a, bool b);
 560
 561
 562 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 563     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 564         bool found;                                                     \
 565         wxPyBeginBlockThreads();                    \
 566         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
 567             PyObject* obj = wxPyMake_wxObject(&a);                      \
 568             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
 569             Py_DECREF(obj);                                             \
 570         }                                                               \
 571         wxPyEndBlockThreads();                                     \
 572         if (! found)                                                    \
 573             PCLASS::CBNAME(a, b);                                       \
 574     }                                                                   \
 575     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 576         PCLASS::CBNAME(a, b);                                           \
 577     }
 578
 579 //---------------------------------------------------------------------------
 580
 581 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
 582     void CBNAME(double a, double b);                    \
 583     void base_##CBNAME(double a, double b);
 584
 585
 586 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
 587     void CLASS::CBNAME(double a, double b) {                            \
 588         bool found;                                                     \
 589         wxPyBeginBlockThreads();                    \
 590         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 591             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));  \
 592         wxPyEndBlockThreads();                                     \
 593         if (! found)                                                    \
 594             PCLASS::CBNAME(a, b);                                       \
 595     }                                                                   \
 596     void CLASS::base_##CBNAME(double a, double b) {                     \
 597         PCLASS::CBNAME(a, b);                                           \
 598     }
 599
 600 //---------------------------------------------------------------------------
 601
 602 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
 603     void CBNAME(double a, double b, int c, int d);              \
 604     void base_##CBNAME(double a, double b, int c, int d);
 605
 606
 607 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 608     void CLASS::CBNAME(double a, double b, int c, int d) {              \
 609         bool found;                                                     \
 610         wxPyBeginBlockThreads();                    \
 611         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 612             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",      \
 613                                                        a,b,c,d));       \
 614         wxPyEndBlockThreads();                                     \
 615         if (! found)                                                    \
 616             PCLASS::CBNAME(a, b, c, d);                                 \
 617     }                                                                   \
 618     void CLASS::base_##CBNAME(double a, double b, int c, int d) {       \
 619         PCLASS::CBNAME(a, b, c, d);                                     \
 620     }
 621
 622 //---------------------------------------------------------------------------
 623
 624 #define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME)                                      \
 625     void CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 626     void base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 627
 628
 629 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
 630     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 631         bool found;                                                                     \
 632         wxPyBeginBlockThreads();                                    \
 633         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
 634             PyObject* obj = wxPyMake_wxObject(&a);                                      \
 635             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
 636             Py_DECREF(obj);                                                             \
 637         }                                                                               \
 638         wxPyEndBlockThreads();                                                     \
 639         if (! found)                                                                    \
 640             PCLASS::CBNAME(a, b, c, d, e, f);                                           \
 641     }                                                                                   \
 642     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 643         PCLASS::CBNAME(a, b, c, d, e, f);                                               \
 644     }
 645
 646 //---------------------------------------------------------------------------
 647
 648 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
 649     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 650     bool base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 651
 652
 653 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
 654     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 655         bool found;                                                                     \
 656         wxPyBeginBlockThreads();                                    \
 657         bool rval=FALSE;                                                                \
 658         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
 659             PyObject* obj = wxPyMake_wxObject(&a);                                      \
 660             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
 661             Py_DECREF(obj);                                                             \
 662         }                                                                               \
 663         wxPyEndBlockThreads();                                                     \
 664         if (! found)                                                                    \
 665             rval = PCLASS::CBNAME(a, b, c, d, e, f);                                    \
 666         return rval;                                                                    \
 667     }                                                                                   \
 668     bool CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 669         return PCLASS::CBNAME(a, b, c, d, e, f);                                        \
 670     }
 671
 672 //---------------------------------------------------------------------------
 673
 674 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
 675     void CBNAME(bool a, double b, double c, int d, int e);              \
 676     void base_##CBNAME(bool a, double b, double c, int d, int e);
 677
 678
 679 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 680     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
 681         bool found;                                                             \
 682         wxPyBeginBlockThreads();                            \
 683         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 684             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \
 685                                                 (int)a,b,c,d,e));               \
 686         wxPyEndBlockThreads();                                             \
 687         if (! found)                                                            \
 688             PCLASS::CBNAME(a, b, c, d, e);                                      \
 689     }                                                                           \
 690     void CLASS::base_##CBNAME(bool a, double b, double c, int d, int e) {       \
 691         PCLASS::CBNAME(a, b, c, d, e);                                          \
 692     }
 693
 694 //---------------------------------------------------------------------------
 695
 696 #define DEC_PYCALLBACK__DC4DBL(CBNAME)                                          \
 697     void CBNAME(wxDC& a, double b, double c, double d, double e);               \
 698     void base_##CBNAME(wxDC& a, double b, double c, double d, double e);
 699
 700
 701 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
 702     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
 703         bool found;                                                             \
 704         wxPyBeginBlockThreads();                            \
 705         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 706             PyObject* obj = wxPyMake_wxObject(&a);                              \
 707             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
 708             Py_DECREF(obj);                                                     \
 709         }                                                                       \
 710         wxPyEndBlockThreads();                                             \
 711         if (! found)                                                            \
 712             PCLASS::CBNAME(a, b, c, d, e);                                      \
 713     }                                                                           \
 714     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e) {\
 715         PCLASS::CBNAME(a, b, c, d, e);                                          \
 716     }
 717
 718 //---------------------------------------------------------------------------
 719
 720 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 721     void CBNAME(wxDC& a, bool b);                       \
 722     void base_##CBNAME(wxDC& a, bool b);
 723
 724
 725 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                           \
 726     void CLASS::CBNAME(wxDC& a, bool b) {                                       \
 727         bool found;                                                             \
 728         wxPyBeginBlockThreads();                            \
 729         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 730             PyObject* obj = wxPyMake_wxObject(&a);                              \
 731             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b)); \
 732             Py_DECREF(obj);                                                     \
 733         }                                                                       \
 734         wxPyEndBlockThreads();                                             \
 735         if (! found)                                                            \
 736             PCLASS::CBNAME(a, b);                                               \
 737     }                                                                           \
 738     void CLASS::base_##CBNAME(wxDC& a, bool b) {                                \
 739         PCLASS::CBNAME(a, b);                                                   \
 740     }
 741
 742 //---------------------------------------------------------------------------
 743
 744 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
 745     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \
 746     void base_##CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);
 747
 748
 749 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 750     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
 751                 int e, int f) {                                                 \
 752         bool found;                                                             \
 753         wxPyBeginBlockThreads();                            \
 754         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 755             PyObject* obj = wxPyMake_wxObject(a);                               \
 756             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
 757             Py_DECREF(obj);                                                     \
 758         }                                                                       \
 759         wxPyEndBlockThreads();                                             \
 760         if (! found)                                                            \
 761             PCLASS::CBNAME(a, b, c, d, e, f);                                   \
 762     }                                                                           \
 763     void CLASS::base_##CBNAME(wxControlPoint* a, bool b, double c, double d,    \
 764                        int e, int f) {                                          \
 765         PCLASS::CBNAME(a, b, c, d, e, f);                                       \
 766     }
 767
 768 //---------------------------------------------------------------------------
 769
 770 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
 771     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \
 772     void base_##CBNAME(wxControlPoint* a, double b, double c, int d, int e);
 773
 774
 775 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 776     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
 777         bool found;                                                             \
 778         wxPyBeginBlockThreads();                            \
 779         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 780             PyObject* obj = wxPyMake_wxObject(a);                               \
 781             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
 782             Py_DECREF(obj);                                                     \
 783         }                                                                       \
 784         wxPyEndBlockThreads();                                             \
 785         if (! found)                                                            \
 786             PCLASS::CBNAME(a, b, c, d, e);                                      \
 787     }                                                                           \
 788     void CLASS::base_##CBNAME(wxControlPoint* a, double b, double c,            \
 789                        int d, int e) {                                          \
 790         PCLASS::CBNAME(a, b, c, d, e);                                          \
 791     }
 792
 793 //---------------------------------------------------------------------------
 794
 795 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
 796     void CBNAME(double a, double b, int c);             \
 797     void base_##CBNAME(double a, double b, int c);
 798
 799
 800 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \
 801     void CLASS::CBNAME(double a, double b, int c) {                             \
 802         bool found;                                                             \
 803         wxPyBeginBlockThreads();                            \
 804         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 805             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));      \
 806         wxPyEndBlockThreads();                                             \
 807         if (! found)                                                            \
 808             PCLASS::CBNAME(a, b, c);                                            \
 809     }                                                                           \
 810     void CLASS::base_##CBNAME(double a, double b, int c) {                      \
 811         PCLASS::CBNAME(a, b, c);                                                \
 812     }
 813
 814 //---------------------------------------------------------------------------
 815
 816 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
 817     void CBNAME(bool a, double b, double c, int d);             \
 818     void base_##CBNAME(bool a, double b, double c, int d);
 819
 820
 821 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
 822     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
 823         bool found;                                                             \
 824         wxPyBeginBlockThreads();                            \
 825         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 826             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\
 827         wxPyEndBlockThreads();                                             \
 828         if (! found)                                                            \
 829             PCLASS::CBNAME(a, b, c, d);                                         \
 830     }                                                                           \
 831     void CLASS::base_##CBNAME(bool a, double b, double c, int d) {              \
 832         PCLASS::CBNAME(a, b, c, d);                                             \
 833     }
 834
 835 //---------------------------------------------------------------------------
 836 //---------------------------------------------------------------------------
 837
 838 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
 839     void CBNAME(const wxString& a);                     \
 840     void base_##CBNAME(const wxString& a);
 841
 842 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                           \
 843     void CLASS::CBNAME(const wxString& a)  {                                    \
 844         bool found;                                                             \
 845         wxPyBeginBlockThreads();                            \
 846         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 847             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));    \
 848         wxPyEndBlockThreads();                                             \
 849         if (! found)                                                            \
 850             PCLASS::CBNAME(a);                                                  \
 851     }                                                                           \
 852     void CLASS::base_##CBNAME(const wxString& a) {                              \
 853         PCLASS::CBNAME(a);                                                      \
 854     }
 855
 856 //---------------------------------------------------------------------------
 857
 858 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
 859     bool CBNAME(const wxString& a);                     \
 860     bool base_##CBNAME(const wxString& a);
 861
 862 #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
 863     bool CLASS::CBNAME(const wxString& a)  {                                    \
 864         bool rval=FALSE;                                                        \
 865         bool found;                                                             \
 866         wxPyBeginBlockThreads();                            \
 867         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 868             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));\
 869         wxPyEndBlockThreads();                                             \
 870         if (! found)                                                            \
 871             rval = PCLASS::CBNAME(a);                                           \
 872         return rval;                                                            \
 873     }                                                                           \
 874     bool CLASS::base_##CBNAME(const wxString& a) {                              \
 875         return PCLASS::CBNAME(a);                                               \
 876     }
 877
 878 //---------------------------------------------------------------------------
 879
 880 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \
 881     bool CBNAME(const wxString& a);
 882
 883 #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME)                          \
 884     bool CLASS::CBNAME(const wxString& a)  {                                            \
 885         bool rval=FALSE;                                                                \
 886         wxPyBeginBlockThreads();                                    \
 887         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                    \
 888             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));     \
 889         wxPyEndBlockThreads();                                                     \
 890         return rval;                                                                    \
 891     }                                                                                   \
 892
 893 //---------------------------------------------------------------------------
 894
 895 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME)                               \
 896     wxString CBNAME(const wxString& a);                                         \
 897
 898 #define IMP_PYCALLBACK_STRING_STRING_pure(CLASS, PCLASS, CBNAME)                \
 899     wxString CLASS::CBNAME(const wxString& a)  {                                \
 900         wxString rval;                                                          \
 901         wxPyBeginBlockThreads();                                                \
 902         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
 903             PyObject* ro;                                                       \
 904             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", wx2PyString(a)));\
 905             if (ro) {                                                           \
 906                 rval = Py2wxString(ro);                                         \
 907                 Py_DECREF(ro);                                                  \
 908             }                                                                   \
 909         }                                                                       \
 910         wxPyEndBlockThreads();                                                  \
 911         return rval;                                                            \
 912     }                                                                           \
 913
 914 //---------------------------------------------------------------------------
 915
 916 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME)                            \
 917     wxString CBNAME(const wxString& a,int b);                                   \
 918
 919 #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME)             \
 920     wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
 921         wxString rval;                                                          \
 922         wxPyBeginBlockThreads();                            \
 923         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
 924             PyObject* ro;                                                       \
 925             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oi)", wx2PyString(a),b));  \
 926             if (ro) {                                                           \
 927                 rval = Py2wxString(ro);                                         \
 928                 Py_DECREF(ro);                                                  \
 929             }                                                                   \
 930         }                                                                       \
 931         wxPyEndBlockThreads();                                                  \
 932         return rval;                                                            \
 933     }                                                                           \
 934
 935 //---------------------------------------------------------------------------
 936
 937 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME)              \
 938     bool CBNAME(const wxString& a, const wxString& b);        \
 939     bool base_##CBNAME(const wxString& a, const wxString& b);
 940
 941 #define IMP_PYCALLBACK_BOOL_STRINGSTRING(CLASS, PCLASS, CBNAME)                 \
 942     bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \
 943         bool rval=FALSE;                                                        \
 944         bool found;                                                             \
 945         wxPyBeginBlockThreads();                            \
 946         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 947             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",         \
 948                                                        wx2PyString(a), wx2PyString(b)));  \
 949         wxPyEndBlockThreads();                                                  \
 950         if (! found)                                                            \
 951             rval = PCLASS::CBNAME(a, b);                                        \
 952         return rval;                                                            \
 953     }                                                                           \
 954     bool CLASS::base_##CBNAME(const wxString& a, const wxString& b) {           \
 955         return PCLASS::CBNAME(a, b);                                            \
 956     }
 957
 958 //---------------------------------------------------------------------------
 959
 960 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
 961     wxString CBNAME();                                  \
 962     wxString base_##CBNAME();
 963
 964 #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
 965     wxString CLASS::CBNAME() {                                                  \
 966         wxString rval;                                                          \
 967         bool found;                                                             \
 968         wxPyBeginBlockThreads();                            \
 969         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 970             PyObject* ro;                                                       \
 971             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
 972             if (ro) {                                                           \
 973                 rval = Py2wxString(ro);                                         \
 974                 Py_DECREF(ro);                                                  \
 975             }                                                                   \
 976         }                                                                       \
 977         wxPyEndBlockThreads();                                                  \
 978         if (! found)                                                            \
 979             rval = PCLASS::CBNAME();                                            \
 980         return rval;                                                            \
 981     }                                                                           \
 982     wxString CLASS::base_##CBNAME() {                                           \
 983         return PCLASS::CBNAME();                                                \
 984     }
 985
 986 //---------------------------------------------------------------------------
 987
 988 #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
 989     wxString CBNAME();
 990
 991 #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
 992     wxString CLASS::CBNAME() {                                                  \
 993         wxString rval;                                                          \
 994         wxPyBeginBlockThreads();                            \
 995         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
 996             PyObject* ro;                                                       \
 997             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
 998             if (ro) {                                                           \
 999                 rval = Py2wxString(ro);                                         \
1000                 Py_DECREF(ro);                                                  \
1001             }                                                                   \
1002         }                                                                       \
1003         wxPyEndBlockThreads();                                                  \
1004         return rval;                                                            \
1005     }
1006
1007 //---------------------------------------------------------------------------
1008
1009 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \
1010     bool CBNAME(const wxHtmlTag& a);                          \
1011
1012
1013 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
1014     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
1015         bool rval=FALSE;                                                        \
1016         wxPyBeginBlockThreads();                            \
1017         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1018             PyObject* obj = wxPyConstructObject((void*)&a, "wxHtmlTag", 0);     \
1019             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
1020             Py_DECREF(obj);                                                     \
1021         }                                                                       \
1022         wxPyEndBlockThreads();                                             \
1023         return rval;                                                            \
1024     }
1025
1026 //---------------------------------------------------------------------------
1027
1028 #define DEC_PYCALLBACK__CELLINTINT(CBNAME)                                      \
1029     void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);                        \
1030     void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);
1031
1032 #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
1033     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
1034         bool found;                                                             \
1035         wxPyBeginBlockThreads();                            \
1036         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1037             PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
1038             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y));  \
1039             Py_DECREF(obj);                                                     \
1040         }                                                                       \
1041         wxPyEndBlockThreads();                                             \
1042         if (! found)                                                            \
1043             PCLASS::CBNAME(cell, x, y);                                         \
1044     }                                                                           \
1045     void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {         \
1046         PCLASS::CBNAME(cell, x, y);                                             \
1047     }
1048
1049
1050 //---------------------------------------------------------------------------
1051
1052 #define DEC_PYCALLBACK__CELLINTINTME(CBNAME)                                    \
1053     void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e); \
1054     void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e);
1055
1056 #define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
1057     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
1058         bool found;                                                             \
1059         wxPyBeginBlockThreads();                            \
1060         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1061             PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
1062             PyObject* o2  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0);  \
1063             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OiiO)",obj,x,y,o2));  \
1064             Py_DECREF(obj);                                                     \
1065             Py_DECREF(o2);                                                      \
1066         }                                                                       \
1067         wxPyEndBlockThreads();                                             \
1068         if (! found)                                                            \
1069             PCLASS::CBNAME(cell, x, y, e);                                         \
1070     }                                                                           \
1071     void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {         \
1072         PCLASS::CBNAME(cell, x, y, e);                                             \
1073     }
1074
1075
1076
1077 //---------------------------------------------------------------------------
1078
1079 #define DEC_PYCALLBACK___pure(CBNAME)                         \
1080     void CBNAME();                                            \
1081
1082
1083 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
1084     void CLASS::CBNAME() {                                                      \
1085         wxPyBeginBlockThreads();                            \
1086         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
1087             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
1088         wxPyEndBlockThreads();                                             \
1089     }
1090
1091 //---------------------------------------------------------------------------
1092
1093 #define DEC_PYCALLBACK_wxSize__pure(CBNAME)                         \
1094     wxSize CBNAME();                                                \
1095
1096
1097 #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME)                      \
1098     wxSize CLASS::CBNAME() {                                                    \
1099         const char* errmsg = #CBNAME " should return a 2-tuple of integers or a wxSize object."; \
1100         wxSize rval(0,0);                                                       \
1101         wxPyBeginBlockThreads();                                                \
1102         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1103             PyObject* ro;                                                       \
1104             wxSize*   ptr;                                                      \
1105             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
1106             if (ro) {                                                           \
1107                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))           \
1108                     rval = *ptr;                                                \
1109                 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {    \
1110                     PyObject* o1 = PySequence_GetItem(ro, 0);                   \
1111                     PyObject* o2 = PySequence_GetItem(ro, 1);                   \
1112                     if (PyNumber_Check(o1) && PyNumber_Check(o2))               \
1113                         rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));      \
1114                     else                                                        \
1115                         PyErr_SetString(PyExc_TypeError, errmsg);               \
1116                     Py_DECREF(o1);                                              \
1117                     Py_DECREF(o2);                                              \
1118                 }                                                               \
1119                 else {                                                          \
1120                     PyErr_SetString(PyExc_TypeError, errmsg);                   \
1121                 }                                                               \
1122                 Py_DECREF(ro);                                                  \
1123             }                                                                   \
1124         }                                                                       \
1125         wxPyEndBlockThreads();                                                  \
1126         return rval;                                                            \
1127     }
1128
1129 //---------------------------------------------------------------------------
1130
1131 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME)                      \
1132     bool CBNAME(wxWindow* a);                                  \
1133     bool base_##CBNAME(wxWindow* a);
1134
1135
1136 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                        \
1137     bool CLASS::CBNAME(wxWindow* a) {                                           \
1138         bool rval=FALSE;                                                        \
1139         bool found;                                                             \
1140         wxPyBeginBlockThreads();                            \
1141         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1142             PyObject* obj = wxPyMake_wxObject(a);                               \
1143             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
1144             Py_DECREF(obj);                                                     \
1145         }                                                                       \
1146         wxPyEndBlockThreads();                                             \
1147         if (! found)                                                            \
1148             rval = PCLASS::CBNAME(a);                                           \
1149         return rval;                                                            \
1150     }                                                                           \
1151     bool CLASS::base_##CBNAME(wxWindow* a) {                                    \
1152         return PCLASS::CBNAME(a);                                               \
1153     }
1154
1155 //---------------------------------------------------------------------------
1156
1157 #define DEC_PYCALLBACK_BOOL_(CBNAME)                      \
1158     bool CBNAME();                                        \
1159     bool base_##CBNAME();
1160
1161
1162 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                             \
1163     bool CLASS::CBNAME() {                                                      \
1164         bool rval=FALSE;                                                        \
1165         bool found;                                                             \
1166         wxPyBeginBlockThreads();                            \
1167         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
1168             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
1169         wxPyEndBlockThreads();                                             \
1170         if (! found)                                                            \
1171             rval = PCLASS::CBNAME();                                            \
1172         return rval;                                                            \
1173     }                                                                           \
1174     bool CLASS::base_##CBNAME() {                                               \
1175         return PCLASS::CBNAME();                                                \
1176     }
1177
1178 //---------------------------------------------------------------------------
1179
1180 #define DEC_PYCALLBACK_DR_2WXCDR(CBNAME)                                \
1181     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);        \
1182     wxDragResult base_##CBNAME(wxCoord x, wxCoord y, wxDragResult def);
1183
1184
1185 #define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                         \
1186     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {          \
1187         int rval=0;                                                             \
1188         bool found;                                                             \
1189         wxPyBeginBlockThreads();                                                \
1190         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
1191             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1192         wxPyEndBlockThreads();                                                  \
1193         if (! found)                                                            \
1194             rval = PCLASS::CBNAME(a, b, c);                                     \
1195         return (wxDragResult)rval;                                              \
1196     }                                                                           \
1197     wxDragResult CLASS::base_##CBNAME(wxCoord a, wxCoord b, wxDragResult c) {   \
1198         return PCLASS::CBNAME(a, b, c);                                         \
1199     }
1200
1201 //---------------------------------------------------------------------------
1202
1203 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \
1204     wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location);       \
1205
1206 #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
1207     wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
1208         wxPyBeginBlockThreads();                                        \
1209         wxFSFile* rval=0;                                               \
1210         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \
1211             PyObject* ro;                                               \
1212             PyObject* obj = wxPyMake_wxObject(&a);                      \
1213             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)",\
1214                                           obj, wx2PyString(b)));        \
1215             if (ro) {                                                   \
1216                 SWIG_GetPtrObj(ro, (void **)&rval, "_wxFSFILE_p");      \
1217                 Py_DECREF(ro);                                          \
1218             }                                                           \
1219             Py_DECREF(obj);                                             \
1220         }                                                               \
1221         wxPyEndBlockThreads();                                          \
1222         return rval;                                                    \
1223     };
1224
1225 //---------------------------------------------------------------------------
1226
1227 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
1228     bool CBNAME(wxDragResult a);                        \
1229     bool base_##CBNAME(wxDragResult a);
1230
1231
1232 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \
1233     bool CLASS::CBNAME(wxDragResult a) {                                \
1234         bool rval=FALSE;                                                \
1235         bool found;                                                     \
1236         wxPyBeginBlockThreads();                                        \
1237         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
1238             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));\
1239         wxPyEndBlockThreads();                                          \
1240         if (! found)                                                    \
1241             rval = PCLASS::CBNAME(a);                                   \
1242         return rval;                                                    \
1243     }                                                                   \
1244     bool CLASS::base_##CBNAME(wxDragResult a) {                         \
1245         return PCLASS::CBNAME(a);                                       \
1246     }
1247
1248 //---------------------------------------------------------------------------
1249
1250 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME)   \
1251     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);
1252
1253
1254 #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)            \
1255     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
1256         wxPyBeginBlockThreads();                                        \
1257         int rval=0;                                                     \
1258         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
1259             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1260         wxPyEndBlockThreads();                                          \
1261         return (wxDragResult)rval;                                      \
1262     }                                                                   \
1263
1264 //---------------------------------------------------------------------------
1265
1266 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \
1267     bool CBNAME(int a, int b, const wxString& c);
1268
1269 #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
1270     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
1271         bool rval=FALSE;                                                \
1272         wxPyBeginBlockThreads();                                        \
1273         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
1274             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b, wx2PyString(c)));\
1275         wxPyEndBlockThreads();                                          \
1276         return rval;                                                    \
1277     }                                                                   \
1278
1279 //---------------------------------------------------------------------------
1280
1281 #define DEC_PYCALLBACK_SIZET_(CBNAME)                  \
1282     size_t CBNAME();                                   \
1283     size_t base_##CBNAME();
1284
1285
1286 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
1287     size_t CLASS::CBNAME() {                                                    \
1288         size_t rval=0;                                                          \
1289         bool found;                                                             \
1290         wxPyBeginBlockThreads();                                                \
1291         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
1292             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
1293         wxPyEndBlockThreads();                                                  \
1294         if (! found)                                                            \
1295             rval = PCLASS::CBNAME();                                            \
1296         return rval;                                                            \
1297     }                                                                           \
1298     size_t CLASS::base_##CBNAME() {                                             \
1299         return PCLASS::CBNAME();                                                \
1300     }
1301
1302 //---------------------------------------------------------------------------
1303
1304 #define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME)                                    \
1305     wxDataFormat  CBNAME(size_t a);                                             \
1306     wxDataFormat  base_##CBNAME(size_t a);
1307
1308
1309 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
1310     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
1311         wxDataFormat rval=0;                                                    \
1312         bool found;                                                             \
1313         wxPyBeginBlockThreads();                                                \
1314         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1315             PyObject* ro;                                                       \
1316             wxDataFormat* ptr;                                                  \
1317             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \
1318             if (ro) {                                                           \
1319                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxDataFormat_p"))     \
1320                     rval = *ptr;                                                \
1321                 Py_DECREF(ro);                                                  \
1322             }                                                                   \
1323         }                                                                       \
1324         wxPyEndBlockThreads();                                                  \
1325         if (! found)                                                            \
1326             rval = PCLASS::CBNAME(a);                                           \
1327         return rval;                                                            \
1328     }                                                                           \
1329     wxDataFormat  CLASS::base_##CBNAME(size_t a) {                              \
1330         return PCLASS::CBNAME(a);                                               \
1331     }
1332
1333 //---------------------------------------------------------------------------
1334
1335 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
1336     void CBNAME(const Type& a);                         \
1337     void base_##CBNAME(const Type& a);
1338
1339
1340 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
1341     void CLASS::CBNAME(const Type& a) {                                         \
1342         bool found;                                                             \
1343         wxPyBeginBlockThreads();                                                \
1344         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1345             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
1346             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
1347             Py_DECREF(obj);                                                     \
1348         }                                                                       \
1349         wxPyEndBlockThreads();                                                  \
1350         if (! found)                                                            \
1351             PCLASS::CBNAME(a);                                                  \
1352     }                                                                           \
1353     void CLASS::base_##CBNAME(const Type& a) {                                  \
1354         PCLASS::CBNAME(a);                                                      \
1355     }
1356
1357
1358 //---------------------------------------------------------------------------
1359
1360 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
1361     void CBNAME(Type& a);                          \
1362     void base_##CBNAME(Type& a);
1363
1364
1365 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
1366     void CLASS::CBNAME(Type& a) {                                               \
1367         bool found;                                                             \
1368         wxPyBeginBlockThreads();                                                \
1369         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1370             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
1371             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
1372             Py_DECREF(obj);                                                     \
1373         }                                                                       \
1374         wxPyEndBlockThreads();                                                  \
1375         if (! found)                                                            \
1376             PCLASS::CBNAME(a);                                                  \
1377     }                                                                           \
1378     void CLASS::base_##CBNAME(Type& a) {                                        \
1379         PCLASS::CBNAME(a);                                                      \
1380     }
1381
1382 //---------------------------------------------------------------------------
1383
1384 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
1385     bool CBNAME(Type& a);                               \
1386     bool base_##CBNAME(Type& a);
1387
1388
1389 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
1390     bool CLASS::CBNAME(Type& a) {                                               \
1391         bool rv=FALSE;                                                          \
1392         bool found;                                                             \
1393         wxPyBeginBlockThreads();                                                \
1394         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1395             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
1396             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
1397             Py_DECREF(obj);                                                     \
1398         }                                                                       \
1399         wxPyEndBlockThreads();                                                  \
1400         if (! found)                                                            \
1401             rv = PCLASS::CBNAME(a);                                             \
1402         return rv;                                                              \
1403     }                                                                           \
1404     bool CLASS::base_##CBNAME(Type& a) {                                        \
1405         return PCLASS::CBNAME(a);                                               \
1406     }
1407
1408 //---------------------------------------------------------------------------
1409
1410 #define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME)                                  \
1411     wxString CBNAME(long a, long b) const;                                      \
1412     wxString base_##CBNAME(long a, long b)const ;
1413
1414 #define IMP_PYCALLBACK_STRING_LONGLONG(CLASS, PCLASS, CBNAME)                   \
1415     wxString CLASS::CBNAME(long a, long b) const {                              \
1416         wxString rval;                                                          \
1417         bool found;                                                             \
1418         wxPyBeginBlockThreads();                                                \
1419         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1420             PyObject* ro;                                                       \
1421             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \
1422             if (ro) {                                                           \
1423                 rval = Py2wxString(ro);                                         \
1424                 Py_DECREF(ro);                                                  \
1425             }                                                                   \
1426         }                                                                       \
1427         wxPyEndBlockThreads();                                                  \
1428         if (! found)                                                            \
1429             rval = PCLASS::CBNAME(a,b);                                         \
1430         return rval;                                                            \
1431     }                                                                           \
1432     wxString CLASS::base_##CBNAME(long a, long b) const {                       \
1433         return PCLASS::CBNAME(a,b);                                             \
1434     }
1435
1436 //---------------------------------------------------------------------------
1437
1438 #define DEC_PYCALLBACK_INT_LONG(CBNAME)                                         \
1439     int CBNAME(long a) const;                                                   \
1440     int base_##CBNAME(long a)const ;
1441
1442
1443 #define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME)                          \
1444     int CLASS::CBNAME(long a) const {                                           \
1445         int rval=-1;                                                            \
1446         bool found;                                                             \
1447         wxPyBeginBlockThreads();                                                \
1448         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1449             PyObject* ro;                                                       \
1450             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
1451             if (ro) {                                                           \
1452                 rval = PyInt_AsLong(ro);                                        \
1453                 Py_DECREF(ro);                                                  \
1454             }                                                                   \
1455         }                                                                       \
1456         wxPyEndBlockThreads();                                                  \
1457         if (! found)                                                            \
1458             rval = PCLASS::CBNAME(a);                                           \
1459         return rval;                                                            \
1460     }                                                                           \
1461     int CLASS::base_##CBNAME(long a) const {                                    \
1462         return PCLASS::CBNAME(a);                                               \
1463     }
1464
1465
1466 //---------------------------------------------------------------------------
1467
1468 #define DEC_PYCALLBACK_LISTATTR_LONG(CBNAME)                                    \
1469     wxListItemAttr*  CBNAME(long a) const;                                      \
1470     wxListItemAttr*  base_##CBNAME(long a);
1471
1472
1473 #define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME)                     \
1474     wxListItemAttr *CLASS::CBNAME(long a) const {                               \
1475         wxListItemAttr *rval = NULL;                                            \
1476         bool found;                                                             \
1477         wxPyBeginBlockThreads();                                                \
1478         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1479             PyObject* ro;                                                       \
1480             wxListItemAttr* ptr;                                                \
1481             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \
1482             if (ro) {                                                           \
1483                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxListItemAttr_p"))   \
1484                     rval = ptr;                                                 \
1485                 Py_DECREF(ro);                                                  \
1486             }                                                                   \
1487         }                                                                       \
1488         wxPyEndBlockThreads();                                                  \
1489         if (! found)                                                            \
1490             rval = PCLASS::CBNAME(a);                                           \
1491         return rval;                                                            \
1492     }                                                                           \
1493     wxListItemAttr *CLASS::base_##CBNAME(long a) {                              \
1494         return PCLASS::CBNAME(a);                                               \
1495     }
1496
1497 //---------------------------------------------------------------------------
1498
1499 #define DEC_PYCALLBACK_BOOL_ME(CBNAME)                                          \
1500     bool CBNAME(wxMouseEvent& e);                                               \
1501     bool base_##CBNAME(wxMouseEvent& e);
1502
1503 #define IMP_PYCALLBACK_BOOL_ME(CLASS, PCLASS, CBNAME)                           \
1504     bool CLASS::CBNAME(wxMouseEvent& e) {                                       \
1505         bool rval=FALSE;                                                        \
1506         bool found;                                                             \
1507         wxPyBeginBlockThreads();                                                \
1508         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1509             PyObject* ro;                                                       \
1510             PyObject* obj  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0); \
1511             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj));   \
1512             if (ro) {                                                           \
1513                 rval = PyInt_AsLong(ro);                                        \
1514                 Py_DECREF(ro);                                                  \
1515             }                                                                   \
1516             Py_DECREF(obj);                                                     \
1517         }                                                                       \
1518         wxPyEndBlockThreads();                                                  \
1519         if (! found)                                                            \
1520             return PCLASS::CBNAME(e);                                           \
1521         return rval;                                                            \
1522     }                                                                           \
1523     bool CLASS::base_##CBNAME(wxMouseEvent& e) {                                \
1524         return PCLASS::CBNAME(e);                                               \
1525     }
1526
1527
1528 //---------------------------------------------------------------------------
1529
1530 #endif