wxPython/src/helpers.h

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        helpers.h
   3 // Purpose:     Helper functions/classes for the wxPython extension 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 // Notice that this is static, not extern.  This is by design, each module
 282 // needs one, but doesn't have to use it.
 283 static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;
 284 #endif
 285
 286
 287 //---------------------------------------------------------------------------
 288
 289
 290 class wxPyUserData : public wxObject {
 291 public:
 292     wxPyUserData(PyObject* obj) {
 293         m_obj = obj;
 294         Py_INCREF(m_obj);
 295     }
 296
 297     ~wxPyUserData() {
 298 #ifdef wxPyUSE_EXPORT
 299         wxPyCoreAPIPtr->p_wxPyUserData_dtor(this);
 300 #else
 301         wxPyUserData_dtor(this);
 302 #endif
 303     }
 304     PyObject* m_obj;
 305 };
 306
 307
 308 class wxPyClientData : public wxClientData {
 309 public:
 310     wxPyClientData(PyObject* obj) {
 311         m_obj = obj;
 312         Py_INCREF(m_obj);
 313     }
 314
 315     ~wxPyClientData() {
 316 #ifdef wxPyUSE_EXPORT
 317         wxPyCoreAPIPtr->p_wxPyClientData_dtor(this);
 318 #else
 319         wxPyClientData_dtor(this);
 320 #endif
 321     }
 322     PyObject* m_obj;
 323 };
 324
 325
 326 class wxPyOORClientData : public wxPyClientData {
 327 public:
 328     wxPyOORClientData(PyObject* obj)
 329         : wxPyClientData(obj) {}
 330
 331     ~wxPyOORClientData() {
 332 #ifdef wxPyUSE_EXPORT
 333         wxPyCoreAPIPtr->p_wxPyOORClientData_dtor(this);
 334 #else
 335         wxPyOORClientData_dtor(this);
 336 #endif
 337     }
 338 };
 339
 340 //---------------------------------------------------------------------------
 341 // This class holds an instance of a Python Shadow Class object and assists
 342 // with looking up and invoking Python callback methods from C++ virtual
 343 // method redirections.  For all classes which have virtuals which should be
 344 // overridable in wxPython, a new subclass is created that contains a
 345 // wxPyCallbackHelper.
 346 //
 347
 348 class wxPyCallbackHelper {
 349 public:
 350     wxPyCallbackHelper(const wxPyCallbackHelper& other);
 351
 352     wxPyCallbackHelper() {
 353         m_class = NULL;
 354         m_self = NULL;
 355         m_lastFound = NULL;
 356         m_incRef = FALSE;
 357     }
 358
 359     ~wxPyCallbackHelper() {
 360 #ifdef wxPyUSE_EXPORT
 361         wxPyCoreAPIPtr->p_wxPyCBH_delete(this);
 362 #else
 363         wxPyCBH_delete(this);
 364 #endif
 365     }
 366
 367     void        setSelf(PyObject* self, PyObject* klass, int incref=TRUE);
 368     bool        findCallback(const char* name) const;
 369     int         callCallback(PyObject* argTuple) const;
 370     PyObject*   callCallbackObj(PyObject* argTuple) const;
 371
 372 private:
 373     PyObject*   m_self;
 374     PyObject*   m_class;
 375     PyObject*   m_lastFound;
 376     int         m_incRef;
 377
 378     friend      void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 379 };
 380
 381
 382 void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
 383 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name);
 384 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 385 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 386 void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 387
 388
 389
 390
 391 //---------------------------------------------------------------------------
 392 // These macros are used to implement the virtual methods that should
 393 // redirect to a Python method if one exists.  The names designate the
 394 // return type, if any, as well as any parameter types.
 395 //---------------------------------------------------------------------------
 396
 397 #define PYPRIVATE                                                       \
 398     void _setCallbackInfo(PyObject* self, PyObject* _class, int incref=1) {     \
 399         wxPyCBH_setCallbackInfo(m_myInst, self, _class, incref);                \
 400     }                                                                   \
 401     private: wxPyCallbackHelper m_myInst
 402
 403 //---------------------------------------------------------------------------
 404
 405 #define DEC_PYCALLBACK__(CBNAME)                        \
 406     void CBNAME();                                      \
 407     void base_##CBNAME();
 408
 409
 410 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)                         \
 411     void CLASS::CBNAME() {                                              \
 412         bool found;                                                     \
 413         wxPyBeginBlockThreads();                    \
 414         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 415             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));        \
 416         wxPyEndBlockThreads();                                     \
 417         if (! found)                                                    \
 418             PCLASS::CBNAME();                                           \
 419     }                                                                   \
 420     void CLASS::base_##CBNAME() {                                       \
 421         PCLASS::CBNAME();                                               \
 422     }
 423
 424 //---------------------------------------------------------------------------
 425
 426 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
 427     bool CBNAME(int a, int b);                                  \
 428     bool base_##CBNAME(int a, int b);
 429
 430
 431 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
 432     bool CLASS::CBNAME(int a, int b) {                                  \
 433         bool rval=FALSE, found;                                         \
 434         wxPyBeginBlockThreads();                    \
 435         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 436             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \
 437         wxPyEndBlockThreads();                                     \
 438         if (! found)                                                    \
 439             rval = PCLASS::CBNAME(a,b);                                 \
 440         return rval;                                                    \
 441     }                                                                   \
 442     bool CLASS::base_##CBNAME(int a, int b) {                           \
 443         return PCLASS::CBNAME(a,b);                                     \
 444     }
 445
 446 //---------------------------------------------------------------------------
 447
 448 #define DEC_PYCALLBACK_VOID_INTINT(CBNAME)                      \
 449     void CBNAME(int a, int b);                                  \
 450     void base_##CBNAME(int a, int b);
 451
 452
 453 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
 454     void CLASS::CBNAME(int a, int b) {                                  \
 455         bool found;                                                     \
 456         wxPyBeginBlockThreads();                                        \
 457         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 458             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));  \
 459         wxPyEndBlockThreads();                                          \
 460         if (! found)                                                    \
 461             PCLASS::CBNAME(a,b);                                        \
 462     }                                                                   \
 463     void CLASS::base_##CBNAME(int a, int b) {                           \
 464         PCLASS::CBNAME(a,b);                                            \
 465     }
 466
 467 //---------------------------------------------------------------------------
 468
 469 #define DEC_PYCALLBACK_VOID_INT4(CBNAME)                                \
 470     void CBNAME(int a, int b, int c, int d);                            \
 471     void base_##CBNAME(int a, int b, int c, int d);
 472
 473
 474 #define IMP_PYCALLBACK_VOID_INT4(CLASS, PCLASS, CBNAME)                 \
 475     void CLASS::CBNAME(int a, int b, int c, int d) {                    \
 476         bool found;                                                     \
 477         wxPyBeginBlockThreads();                                        \
 478         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 479             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiii)",a,b,c,d));  \
 480         wxPyEndBlockThreads();                                          \
 481         if (! found)                                                    \
 482             PCLASS::CBNAME(a,b,c,d);                                    \
 483     }                                                                   \
 484     void CLASS::base_##CBNAME(int a, int b, int c, int d) {             \
 485         PCLASS::CBNAME(a,b,c,d);                                        \
 486     }
 487
 488 //---------------------------------------------------------------------------
 489 #define DEC_PYCALLBACK_VOID_INT5(CBNAME)                                \
 490     void CBNAME(int a, int b, int c, int d, int e);                     \
 491     void base_##CBNAME(int a, int b, int c, int d, int e);
 492
 493
 494 #define IMP_PYCALLBACK_VOID_INT5(CLASS, PCLASS, CBNAME)                 \
 495     void CLASS::CBNAME(int a, int b, int c, int d, int e) {             \
 496         bool found;                                                     \
 497         wxPyBeginBlockThreads();                                        \
 498         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 499             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiiii)",a,b,c,d,e));  \
 500         wxPyEndBlockThreads();                                          \
 501         if (! found)                                                    \
 502             PCLASS::CBNAME(a,b,c,d,e);                                  \
 503     }                                                                   \
 504     void CLASS::base_##CBNAME(int a, int b, int c, int d, int e) {      \
 505         PCLASS::CBNAME(a,b,c,d,e);                                      \
 506     }
 507
 508 //---------------------------------------------------------------------------
 509
 510 #define DEC_PYCALLBACK_VOID_INTPINTP_const(CBNAME)                              \
 511     void CBNAME(int* a, int* b) const;                                          \
 512     void base_##CBNAME(int* a, int* b) const;
 513
 514
 515 #define IMP_PYCALLBACK_VOID_INTPINTP_const(CLASS, PCLASS, CBNAME)               \
 516     void CLASS::CBNAME(int* a, int* b) const {                                  \
 517         const char* errmsg = #CBNAME " should return a 2-tuple of integers.";   \
 518         bool found;                                                             \
 519         wxPyBeginBlockThreads();                                                \
 520         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 521             PyObject* ro;                                                       \
 522             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
 523             if (ro) {                                                           \
 524                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {         \
 525                     PyObject* o1 = PySequence_GetItem(ro, 0);                   \
 526                     PyObject* o2 = PySequence_GetItem(ro, 1);                   \
 527                     if (PyNumber_Check(o1) && PyNumber_Check(o2)) {             \
 528                         *a = PyInt_AsLong(o1); *b = PyInt_AsLong(o2);           \
 529                     }                                                           \
 530                     else                                                        \
 531                         PyErr_SetString(PyExc_TypeError, errmsg);               \
 532                     Py_DECREF(o1);                                              \
 533                     Py_DECREF(o2);                                              \
 534                 }                                                               \
 535                 else {                                                          \
 536                     PyErr_SetString(PyExc_TypeError, errmsg);                   \
 537                 }                                                               \
 538                 Py_DECREF(ro);                                                  \
 539             }                                                                   \
 540         }                                                                       \
 541         wxPyEndBlockThreads();                                                  \
 542         if (! found)                                                            \
 543             PCLASS::CBNAME(a,b);                                                \
 544     }                                                                           \
 545     void CLASS::base_##CBNAME(int* a, int* b) const {                           \
 546         PCLASS::CBNAME(a,b);                                                    \
 547     }
 548
 549
 550 //---------------------------------------------------------------------------
 551
 552 #define DEC_PYCALLBACK_SIZE_const(CBNAME)                                       \
 553     wxSize CBNAME() const;                                                      \
 554     wxSize base_##CBNAME() const;
 555
 556
 557 #define IMP_PYCALLBACK_SIZE_const(CLASS, PCLASS, CBNAME)                        \
 558     wxSize CLASS::CBNAME() const {                                              \
 559         const char* errmsg = #CBNAME " should return a 2-tuple of integers.";   \
 560         bool found; wxSize rval(0,0);                                           \
 561         wxPyBeginBlockThreads();                                                \
 562         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 563             PyObject* ro;                                                       \
 564             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
 565             if (ro) {                                                           \
 566                 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {         \
 567                     PyObject* o1 = PySequence_GetItem(ro, 0);                   \
 568                     PyObject* o2 = PySequence_GetItem(ro, 1);                   \
 569                     if (PyNumber_Check(o1) && PyNumber_Check(o2)) {             \
 570                         rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));      \
 571                     }                                                           \
 572                     else                                                        \
 573                         PyErr_SetString(PyExc_TypeError, errmsg);               \
 574                     Py_DECREF(o1);                                              \
 575                     Py_DECREF(o2);                                              \
 576                 }                                                               \
 577                 else {                                                          \
 578                     PyErr_SetString(PyExc_TypeError, errmsg);                   \
 579                 }                                                               \
 580                 Py_DECREF(ro);                                                  \
 581             }                                                                   \
 582         }                                                                       \
 583         wxPyEndBlockThreads();                                                  \
 584         if (! found)                                                            \
 585             return PCLASS::CBNAME();                                            \
 586         else                                                                    \
 587             return rval;                                                        \
 588     }                                                                           \
 589     wxSize CLASS::base_##CBNAME() const {                                       \
 590         return PCLASS::CBNAME();                                                \
 591     }
 592
 593
 594 //---------------------------------------------------------------------------
 595
 596 #define DEC_PYCALLBACK_BOOL_INT(CBNAME)                         \
 597     bool CBNAME(int a);                                         \
 598     bool base_##CBNAME(int a);
 599
 600
 601 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
 602     bool CLASS::CBNAME(int a) {                                         \
 603         bool rval=FALSE, found;                                         \
 604         wxPyBeginBlockThreads();                                        \
 605         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 606             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
 607         wxPyEndBlockThreads();                                          \
 608         if (! found)                                                    \
 609             rval = PCLASS::CBNAME(a);                                   \
 610         return rval;                                                    \
 611     }                                                                   \
 612     bool CLASS::base_##CBNAME(int a) {                                  \
 613         return PCLASS::CBNAME(a);                                       \
 614     }
 615
 616 //---------------------------------------------------------------------------
 617
 618 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \
 619     bool CBNAME(int a);
 620
 621
 622 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
 623     bool CLASS::CBNAME(int a) {                                         \
 624         bool rval=FALSE;                                                \
 625         wxPyBeginBlockThreads();                    \
 626         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
 627             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
 628         else rval = FALSE;                                              \
 629         wxPyEndBlockThreads();                                     \
 630         return rval;                                                    \
 631     }
 632
 633
 634 //---------------------------------------------------------------------------
 635
 636 #define DEC_PYCALLBACK__DC(CBNAME)                      \
 637     void CBNAME(wxDC& a);                               \
 638     void base_##CBNAME(wxDC& a);
 639
 640
 641 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)                       \
 642     void CLASS::CBNAME(wxDC& a) {                                       \
 643         bool found;                                                     \
 644         wxPyBeginBlockThreads();                    \
 645         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
 646             PyObject* obj = wxPyMake_wxObject(&a);                      \
 647             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));  \
 648             Py_DECREF(obj);                                             \
 649         }                                                               \
 650         wxPyEndBlockThreads();                                     \
 651         if (! found)                                                    \
 652             PCLASS::CBNAME(a);                                          \
 653     }                                                                   \
 654     void CLASS::base_##CBNAME(wxDC& a) {                                \
 655         PCLASS::CBNAME(a);                                              \
 656     }
 657
 658
 659
 660 //---------------------------------------------------------------------------
 661
 662 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 663     void CBNAME(wxDC& a, bool b);                       \
 664     void base_##CBNAME(wxDC& a, bool b);
 665
 666
 667 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 668     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 669         bool found;                                                     \
 670         wxPyBeginBlockThreads();                    \
 671         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
 672             PyObject* obj = wxPyMake_wxObject(&a);                      \
 673             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
 674             Py_DECREF(obj);                                             \
 675         }                                                               \
 676         wxPyEndBlockThreads();                                     \
 677         if (! found)                                                    \
 678             PCLASS::CBNAME(a, b);                                       \
 679     }                                                                   \
 680     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 681         PCLASS::CBNAME(a, b);                                           \
 682     }
 683
 684 //---------------------------------------------------------------------------
 685
 686 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
 687     void CBNAME(wxDC& a, bool b);                               \
 688     void base_##CBNAME(wxDC& a, bool b);
 689
 690
 691 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 692     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 693         bool found;                                                     \
 694         wxPyBeginBlockThreads();                    \
 695         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {        \
 696             PyObject* obj = wxPyMake_wxObject(&a);                      \
 697             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
 698             Py_DECREF(obj);                                             \
 699         }                                                               \
 700         wxPyEndBlockThreads();                                     \
 701         if (! found)                                                    \
 702             PCLASS::CBNAME(a, b);                                       \
 703     }                                                                   \
 704     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 705         PCLASS::CBNAME(a, b);                                           \
 706     }
 707
 708 //---------------------------------------------------------------------------
 709
 710 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
 711     void CBNAME(double a, double b);                    \
 712     void base_##CBNAME(double a, double b);
 713
 714
 715 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)                     \
 716     void CLASS::CBNAME(double a, double b) {                            \
 717         bool found;                                                     \
 718         wxPyBeginBlockThreads();                    \
 719         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 720             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));  \
 721         wxPyEndBlockThreads();                                     \
 722         if (! found)                                                    \
 723             PCLASS::CBNAME(a, b);                                       \
 724     }                                                                   \
 725     void CLASS::base_##CBNAME(double a, double b) {                     \
 726         PCLASS::CBNAME(a, b);                                           \
 727     }
 728
 729 //---------------------------------------------------------------------------
 730
 731 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
 732     void CBNAME(double a, double b, int c, int d);              \
 733     void base_##CBNAME(double a, double b, int c, int d);
 734
 735
 736 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 737     void CLASS::CBNAME(double a, double b, int c, int d) {              \
 738         bool found;                                                     \
 739         wxPyBeginBlockThreads();                    \
 740         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
 741             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",      \
 742                                                        a,b,c,d));       \
 743         wxPyEndBlockThreads();                                     \
 744         if (! found)                                                    \
 745             PCLASS::CBNAME(a, b, c, d);                                 \
 746     }                                                                   \
 747     void CLASS::base_##CBNAME(double a, double b, int c, int d) {       \
 748         PCLASS::CBNAME(a, b, c, d);                                     \
 749     }
 750
 751 //---------------------------------------------------------------------------
 752
 753 #define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME)                                      \
 754     void CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 755     void base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 756
 757
 758 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
 759     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 760         bool found;                                                                     \
 761         wxPyBeginBlockThreads();                                    \
 762         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
 763             PyObject* obj = wxPyMake_wxObject(&a);                                      \
 764             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
 765             Py_DECREF(obj);                                                             \
 766         }                                                                               \
 767         wxPyEndBlockThreads();                                                     \
 768         if (! found)                                                                    \
 769             PCLASS::CBNAME(a, b, c, d, e, f);                                           \
 770     }                                                                                   \
 771     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 772         PCLASS::CBNAME(a, b, c, d, e, f);                                               \
 773     }
 774
 775 //---------------------------------------------------------------------------
 776
 777 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
 778     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 779     bool base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 780
 781
 782 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
 783     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 784         bool found;                                                                     \
 785         wxPyBeginBlockThreads();                                    \
 786         bool rval=FALSE;                                                                \
 787         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                        \
 788             PyObject* obj = wxPyMake_wxObject(&a);                                      \
 789             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
 790             Py_DECREF(obj);                                                             \
 791         }                                                                               \
 792         wxPyEndBlockThreads();                                                     \
 793         if (! found)                                                                    \
 794             rval = PCLASS::CBNAME(a, b, c, d, e, f);                                    \
 795         return rval;                                                                    \
 796     }                                                                                   \
 797     bool CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 798         return PCLASS::CBNAME(a, b, c, d, e, f);                                        \
 799     }
 800
 801 //---------------------------------------------------------------------------
 802
 803 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
 804     void CBNAME(bool a, double b, double c, int d, int e);              \
 805     void base_##CBNAME(bool a, double b, double c, int d, int e);
 806
 807
 808 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 809     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
 810         bool found;                                                             \
 811         wxPyBeginBlockThreads();                            \
 812         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 813             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)",             \
 814                                                 (int)a,b,c,d,e));               \
 815         wxPyEndBlockThreads();                                             \
 816         if (! found)                                                            \
 817             PCLASS::CBNAME(a, b, c, d, e);                                      \
 818     }                                                                           \
 819     void CLASS::base_##CBNAME(bool a, double b, double c, int d, int e) {       \
 820         PCLASS::CBNAME(a, b, c, d, e);                                          \
 821     }
 822
 823 //---------------------------------------------------------------------------
 824
 825 #define DEC_PYCALLBACK__DC4DBL(CBNAME)                                          \
 826     void CBNAME(wxDC& a, double b, double c, double d, double e);               \
 827     void base_##CBNAME(wxDC& a, double b, double c, double d, double e);
 828
 829
 830 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
 831     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
 832         bool found;                                                             \
 833         wxPyBeginBlockThreads();                            \
 834         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 835             PyObject* obj = wxPyMake_wxObject(&a);                              \
 836             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
 837             Py_DECREF(obj);                                                     \
 838         }                                                                       \
 839         wxPyEndBlockThreads();                                             \
 840         if (! found)                                                            \
 841             PCLASS::CBNAME(a, b, c, d, e);                                      \
 842     }                                                                           \
 843     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e) {\
 844         PCLASS::CBNAME(a, b, c, d, e);                                          \
 845     }
 846
 847 //---------------------------------------------------------------------------
 848
 849 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 850     void CBNAME(wxDC& a, bool b);                       \
 851     void base_##CBNAME(wxDC& a, bool b);
 852
 853
 854 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                           \
 855     void CLASS::CBNAME(wxDC& a, bool b) {                                       \
 856         bool found;                                                             \
 857         wxPyBeginBlockThreads();                            \
 858         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 859             PyObject* obj = wxPyMake_wxObject(&a);                              \
 860             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b)); \
 861             Py_DECREF(obj);                                                     \
 862         }                                                                       \
 863         wxPyEndBlockThreads();                                             \
 864         if (! found)                                                            \
 865             PCLASS::CBNAME(a, b);                                               \
 866     }                                                                           \
 867     void CLASS::base_##CBNAME(wxDC& a, bool b) {                                \
 868         PCLASS::CBNAME(a, b);                                                   \
 869     }
 870
 871 //---------------------------------------------------------------------------
 872
 873 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
 874     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \
 875     void base_##CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);
 876
 877
 878 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 879     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
 880                 int e, int f) {                                                 \
 881         bool found;                                                             \
 882         wxPyBeginBlockThreads();                            \
 883         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 884             PyObject* obj = wxPyMake_wxObject(a);                               \
 885             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
 886             Py_DECREF(obj);                                                     \
 887         }                                                                       \
 888         wxPyEndBlockThreads();                                             \
 889         if (! found)                                                            \
 890             PCLASS::CBNAME(a, b, c, d, e, f);                                   \
 891     }                                                                           \
 892     void CLASS::base_##CBNAME(wxControlPoint* a, bool b, double c, double d,    \
 893                        int e, int f) {                                          \
 894         PCLASS::CBNAME(a, b, c, d, e, f);                                       \
 895     }
 896
 897 //---------------------------------------------------------------------------
 898
 899 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
 900     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \
 901     void base_##CBNAME(wxControlPoint* a, double b, double c, int d, int e);
 902
 903
 904 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 905     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
 906         bool found;                                                             \
 907         wxPyBeginBlockThreads();                            \
 908         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 909             PyObject* obj = wxPyMake_wxObject(a);                               \
 910             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
 911             Py_DECREF(obj);                                                     \
 912         }                                                                       \
 913         wxPyEndBlockThreads();                                             \
 914         if (! found)                                                            \
 915             PCLASS::CBNAME(a, b, c, d, e);                                      \
 916     }                                                                           \
 917     void CLASS::base_##CBNAME(wxControlPoint* a, double b, double c,            \
 918                        int d, int e) {                                          \
 919         PCLASS::CBNAME(a, b, c, d, e);                                          \
 920     }
 921
 922 //---------------------------------------------------------------------------
 923
 924 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
 925     void CBNAME(double a, double b, int c);             \
 926     void base_##CBNAME(double a, double b, int c);
 927
 928
 929 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                          \
 930     void CLASS::CBNAME(double a, double b, int c) {                             \
 931         bool found;                                                             \
 932         wxPyBeginBlockThreads();                            \
 933         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 934             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));      \
 935         wxPyEndBlockThreads();                                             \
 936         if (! found)                                                            \
 937             PCLASS::CBNAME(a, b, c);                                            \
 938     }                                                                           \
 939     void CLASS::base_##CBNAME(double a, double b, int c) {                      \
 940         PCLASS::CBNAME(a, b, c);                                                \
 941     }
 942
 943 //---------------------------------------------------------------------------
 944
 945 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
 946     void CBNAME(bool a, double b, double c, int d);             \
 947     void base_##CBNAME(bool a, double b, double c, int d);
 948
 949
 950 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
 951     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
 952         bool found;                                                             \
 953         wxPyBeginBlockThreads();                                                \
 954         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 955             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\
 956         wxPyEndBlockThreads();                                                  \
 957         if (! found)                                                            \
 958             PCLASS::CBNAME(a, b, c, d);                                         \
 959     }                                                                           \
 960     void CLASS::base_##CBNAME(bool a, double b, double c, int d) {              \
 961         PCLASS::CBNAME(a, b, c, d);                                             \
 962     }
 963
 964 //---------------------------------------------------------------------------
 965 //---------------------------------------------------------------------------
 966
 967 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
 968     void CBNAME(const wxString& a);                     \
 969     void base_##CBNAME(const wxString& a);
 970
 971 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                           \
 972     void CLASS::CBNAME(const wxString& a)  {                                    \
 973         bool found;                                                             \
 974         wxPyBeginBlockThreads();                                                \
 975         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 976             PyObject* s = wx2PyString(a);                                       \
 977             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));            \
 978             Py_DECREF(s);                                                       \
 979         }                                                                       \
 980         wxPyEndBlockThreads();                                                  \
 981         if (! found)                                                            \
 982             PCLASS::CBNAME(a);                                                  \
 983     }                                                                           \
 984     void CLASS::base_##CBNAME(const wxString& a) {                              \
 985         PCLASS::CBNAME(a);                                                      \
 986     }
 987
 988 //---------------------------------------------------------------------------
 989
 990 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
 991     bool CBNAME(const wxString& a);                     \
 992     bool base_##CBNAME(const wxString& a);
 993
 994 #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
 995     bool CLASS::CBNAME(const wxString& a)  {                                    \
 996         bool rval=FALSE;                                                        \
 997         bool found;                                                             \
 998         wxPyBeginBlockThreads();                                                \
 999         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1000             PyObject* s = wx2PyString(a);                                       \
1001             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
1002             Py_DECREF(s);                                                       \
1003         }                                                                       \
1004         wxPyEndBlockThreads();                                                  \
1005         if (! found)                                                            \
1006             rval = PCLASS::CBNAME(a);                                           \
1007         return rval;                                                            \
1008     }                                                                           \
1009     bool CLASS::base_##CBNAME(const wxString& a) {                              \
1010         return PCLASS::CBNAME(a);                                               \
1011     }
1012
1013 //---------------------------------------------------------------------------
1014
1015 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \
1016     bool CBNAME(const wxString& a);
1017
1018 #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME)                  \
1019     bool CLASS::CBNAME(const wxString& a)  {                                    \
1020         bool rval=FALSE;                                                        \
1021         wxPyBeginBlockThreads();                                                \
1022         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1023             PyObject* s = wx2PyString(a);                                       \
1024             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));     \
1025             Py_DECREF(s);                                                       \
1026         }                                                                       \
1027         wxPyEndBlockThreads();                                                  \
1028         return rval;                                                            \
1029     }                                                                           \
1030
1031 //---------------------------------------------------------------------------
1032
1033 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME)                               \
1034     wxString CBNAME(const wxString& a);                                         \
1035
1036 #define IMP_PYCALLBACK_STRING_STRING_pure(CLASS, PCLASS, CBNAME)                \
1037     wxString CLASS::CBNAME(const wxString& a)  {                                \
1038         wxString rval;                                                          \
1039         wxPyBeginBlockThreads();                                                \
1040         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1041             PyObject* ro;                                                       \
1042             PyObject* s = wx2PyString(a);                                       \
1043             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", s));    \
1044             Py_DECREF(s);                                                       \
1045             if (ro) {                                                           \
1046                 rval = Py2wxString(ro);                                         \
1047                 Py_DECREF(ro);                                                  \
1048             }                                                                   \
1049         }                                                                       \
1050         wxPyEndBlockThreads();                                                  \
1051         return rval;                                                            \
1052     }                                                                           \
1053
1054 //---------------------------------------------------------------------------
1055
1056 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME)                            \
1057     wxString CBNAME(const wxString& a,int b);                                   \
1058
1059 #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME)             \
1060     wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
1061         wxString rval;                                                          \
1062         wxPyBeginBlockThreads();                                                \
1063         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1064             PyObject* ro;                                                       \
1065             PyObject* s = wx2PyString(a);                                       \
1066             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oi)",s,b));  \
1067             Py_DECREF(s);                                                       \
1068             if (ro) {                                                           \
1069                 rval = Py2wxString(ro);                                         \
1070                 Py_DECREF(ro);                                                  \
1071             }                                                                   \
1072         }                                                                       \
1073         wxPyEndBlockThreads();                                                  \
1074         return rval;                                                            \
1075     }                                                                           \
1076
1077 //---------------------------------------------------------------------------
1078
1079 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME)              \
1080     bool CBNAME(const wxString& a, const wxString& b);        \
1081     bool base_##CBNAME(const wxString& a, const wxString& b);
1082
1083 #define IMP_PYCALLBACK_BOOL_STRINGSTRING(CLASS, PCLASS, CBNAME)                 \
1084     bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \
1085         bool rval=FALSE;                                                        \
1086         bool found;                                                             \
1087         wxPyBeginBlockThreads();                                                \
1088         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1089             PyObject* s1 = wx2PyString(a);                                      \
1090             PyObject* s2 = wx2PyString(b);                                      \
1091             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",s1,s2)); \
1092             Py_DECREF(s1);                                                      \
1093             Py_DECREF(s2);                                                      \
1094         }                                                                       \
1095         wxPyEndBlockThreads();                                                  \
1096         if (! found)                                                            \
1097             rval = PCLASS::CBNAME(a, b);                                        \
1098         return rval;                                                            \
1099     }                                                                           \
1100     bool CLASS::base_##CBNAME(const wxString& a, const wxString& b) {           \
1101         return PCLASS::CBNAME(a, b);                                            \
1102     }
1103
1104 //---------------------------------------------------------------------------
1105
1106 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
1107     wxString CBNAME();                                  \
1108     wxString base_##CBNAME();
1109
1110 #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
1111     wxString CLASS::CBNAME() {                                                  \
1112         wxString rval;                                                          \
1113         bool found;                                                             \
1114         wxPyBeginBlockThreads();                            \
1115         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1116             PyObject* ro;                                                       \
1117             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
1118             if (ro) {                                                           \
1119                 rval = Py2wxString(ro);                                         \
1120                 Py_DECREF(ro);                                                  \
1121             }                                                                   \
1122         }                                                                       \
1123         wxPyEndBlockThreads();                                                  \
1124         if (! found)                                                            \
1125             rval = PCLASS::CBNAME();                                            \
1126         return rval;                                                            \
1127     }                                                                           \
1128     wxString CLASS::base_##CBNAME() {                                           \
1129         return PCLASS::CBNAME();                                                \
1130     }
1131
1132 //---------------------------------------------------------------------------
1133
1134 #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
1135     wxString CBNAME();
1136
1137 #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
1138     wxString CLASS::CBNAME() {                                                  \
1139         wxString rval;                                                          \
1140         wxPyBeginBlockThreads();                            \
1141         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1142             PyObject* ro;                                                       \
1143             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
1144             if (ro) {                                                           \
1145                 rval = Py2wxString(ro);                                         \
1146                 Py_DECREF(ro);                                                  \
1147             }                                                                   \
1148         }                                                                       \
1149         wxPyEndBlockThreads();                                                  \
1150         return rval;                                                            \
1151     }
1152
1153 //---------------------------------------------------------------------------
1154
1155 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \
1156     bool CBNAME(const wxHtmlTag& a);                          \
1157
1158
1159 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
1160     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
1161         bool rval=FALSE;                                                        \
1162         wxPyBeginBlockThreads();                                                \
1163         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1164             PyObject* obj = wxPyConstructObject((void*)&a, "wxHtmlTag", 0);     \
1165             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
1166             Py_DECREF(obj);                                                     \
1167         }                                                                       \
1168         wxPyEndBlockThreads();                                                  \
1169         return rval;                                                            \
1170     }
1171
1172 //---------------------------------------------------------------------------
1173
1174 #define DEC_PYCALLBACK__CELLINTINT(CBNAME)                                      \
1175     void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);                        \
1176     void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y);
1177
1178 #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME)                       \
1179     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {                \
1180         bool found;                                                             \
1181         wxPyBeginBlockThreads();                                                \
1182         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1183             PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
1184             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y));  \
1185             Py_DECREF(obj);                                                     \
1186         }                                                                       \
1187         wxPyEndBlockThreads();                                                  \
1188         if (! found)                                                            \
1189             PCLASS::CBNAME(cell, x, y);                                         \
1190     }                                                                           \
1191     void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) {         \
1192         PCLASS::CBNAME(cell, x, y);                                             \
1193     }
1194
1195
1196 //---------------------------------------------------------------------------
1197
1198 #define DEC_PYCALLBACK__CELLINTINTME(CBNAME)                                    \
1199     void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e); \
1200     void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e);
1201
1202 #define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME)                       \
1203     void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {                \
1204         bool found;                                                             \
1205         wxPyBeginBlockThreads();                                                \
1206         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1207             PyObject* obj = wxPyConstructObject((void*)cell, "wxHtmlCell", 0);  \
1208             PyObject* o2  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0);  \
1209             wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OiiO)",obj,x,y,o2));  \
1210             Py_DECREF(obj);                                                     \
1211             Py_DECREF(o2);                                                      \
1212         }                                                                       \
1213         wxPyEndBlockThreads();                                                  \
1214         if (! found)                                                            \
1215             PCLASS::CBNAME(cell, x, y, e);                                      \
1216     }                                                                           \
1217     void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {         \
1218         PCLASS::CBNAME(cell, x, y, e);                                          \
1219     }
1220
1221
1222
1223 //---------------------------------------------------------------------------
1224
1225 #define DEC_PYCALLBACK___pure(CBNAME)                         \
1226     void CBNAME();                                            \
1227
1228
1229 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
1230     void CLASS::CBNAME() {                                                      \
1231         wxPyBeginBlockThreads();                                                \
1232         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
1233             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
1234         wxPyEndBlockThreads();                                                  \
1235     }
1236
1237 //---------------------------------------------------------------------------
1238
1239 #define DEC_PYCALLBACK_wxSize__pure(CBNAME)                         \
1240     wxSize CBNAME();                                                \
1241
1242
1243 #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME)                      \
1244     wxSize CLASS::CBNAME() {                                                    \
1245         const char* errmsg = #CBNAME " should return a 2-tuple of integers or a wxSize object."; \
1246         wxSize rval(0,0);                                                       \
1247         wxPyBeginBlockThreads();                                                \
1248         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
1249             PyObject* ro;                                                       \
1250             wxSize*   ptr;                                                      \
1251             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
1252             if (ro) {                                                           \
1253                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))           \
1254                     rval = *ptr;                                                \
1255                 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {    \
1256                     PyObject* o1 = PySequence_GetItem(ro, 0);                   \
1257                     PyObject* o2 = PySequence_GetItem(ro, 1);                   \
1258                     if (PyNumber_Check(o1) && PyNumber_Check(o2))               \
1259                         rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));      \
1260                     else                                                        \
1261                         PyErr_SetString(PyExc_TypeError, errmsg);               \
1262                     Py_DECREF(o1);                                              \
1263                     Py_DECREF(o2);                                              \
1264                 }                                                               \
1265                 else {                                                          \
1266                     PyErr_SetString(PyExc_TypeError, errmsg);                   \
1267                 }                                                               \
1268                 Py_DECREF(ro);                                                  \
1269             }                                                                   \
1270         }                                                                       \
1271         wxPyEndBlockThreads();                                                  \
1272         return rval;                                                            \
1273     }
1274
1275 //---------------------------------------------------------------------------
1276
1277 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME)                      \
1278     bool CBNAME(wxWindow* a);                                  \
1279     bool base_##CBNAME(wxWindow* a);
1280
1281
1282 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                        \
1283     bool CLASS::CBNAME(wxWindow* a) {                                           \
1284         bool rval=FALSE;                                                        \
1285         bool found;                                                             \
1286         wxPyBeginBlockThreads();                                                \
1287         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1288             PyObject* obj = wxPyMake_wxObject(a);                               \
1289             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
1290             Py_DECREF(obj);                                                     \
1291         }                                                                       \
1292         wxPyEndBlockThreads();                                                  \
1293         if (! found)                                                            \
1294             rval = PCLASS::CBNAME(a);                                           \
1295         return rval;                                                            \
1296     }                                                                           \
1297     bool CLASS::base_##CBNAME(wxWindow* a) {                                    \
1298         return PCLASS::CBNAME(a);                                               \
1299     }
1300
1301 //---------------------------------------------------------------------------
1302
1303 #define DEC_PYCALLBACK_BOOL_(CBNAME)                      \
1304     bool CBNAME();                                        \
1305     bool base_##CBNAME();
1306
1307
1308 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                             \
1309     bool CLASS::CBNAME() {                                                      \
1310         bool rval=FALSE;                                                        \
1311         bool found;                                                             \
1312         wxPyBeginBlockThreads();                                                \
1313         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
1314             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
1315         wxPyEndBlockThreads();                                                  \
1316         if (! found)                                                            \
1317             rval = PCLASS::CBNAME();                                            \
1318         return rval;                                                            \
1319     }                                                                           \
1320     bool CLASS::base_##CBNAME() {                                               \
1321         return PCLASS::CBNAME();                                                \
1322     }
1323
1324 //---------------------------------------------------------------------------
1325
1326 #define DEC_PYCALLBACK_BOOL_const(CBNAME)                       \
1327     bool CBNAME() const;                                        \
1328     bool base_##CBNAME() const;
1329
1330
1331 #define IMP_PYCALLBACK_BOOL_const(CLASS, PCLASS, CBNAME)                        \
1332     bool CLASS::CBNAME() const {                                                \
1333         bool rval=FALSE;                                                        \
1334         bool found;                                                             \
1335         wxPyBeginBlockThreads();                                                \
1336         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
1337             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
1338         wxPyEndBlockThreads();                                                  \
1339         if (! found)                                                            \
1340             rval = PCLASS::CBNAME();                                            \
1341         return rval;                                                            \
1342     }                                                                           \
1343     bool CLASS::base_##CBNAME() const {                                         \
1344         return PCLASS::CBNAME();                                                \
1345     }
1346
1347 //---------------------------------------------------------------------------
1348
1349 #define DEC_PYCALLBACK_DR_2WXCDR(CBNAME)                                \
1350     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);        \
1351     wxDragResult base_##CBNAME(wxCoord x, wxCoord y, wxDragResult def);
1352
1353
1354 #define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                         \
1355     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {          \
1356         int rval=0;                                                             \
1357         bool found;                                                             \
1358         wxPyBeginBlockThreads();                                                \
1359         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
1360             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1361         wxPyEndBlockThreads();                                                  \
1362         if (! found)                                                            \
1363             rval = PCLASS::CBNAME(a, b, c);                                     \
1364         return (wxDragResult)rval;                                              \
1365     }                                                                           \
1366     wxDragResult CLASS::base_##CBNAME(wxCoord a, wxCoord b, wxDragResult c) {   \
1367         return PCLASS::CBNAME(a, b, c);                                         \
1368     }
1369
1370 //---------------------------------------------------------------------------
1371
1372 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \
1373     wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location);       \
1374
1375 #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
1376     wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
1377         wxPyBeginBlockThreads();                                        \
1378         wxFSFile* rval=0;                                               \
1379         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \
1380             PyObject* ro;                                               \
1381             PyObject* obj = wxPyMake_wxObject(&a);                      \
1382             PyObject* s = wx2PyString(b);                               \
1383             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)",\
1384                                          obj, s));                      \
1385             if (ro) {                                                   \
1386                 SWIG_GetPtrObj(ro, (void **)&rval, "_wxFSFILE_p");      \
1387                 Py_DECREF(ro);                                          \
1388             }                                                           \
1389             Py_DECREF(obj);                                             \
1390             Py_DECREF(s);                                               \
1391         }                                                               \
1392         wxPyEndBlockThreads();                                          \
1393         return rval;                                                    \
1394     };
1395
1396 //---------------------------------------------------------------------------
1397
1398 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
1399     bool CBNAME(wxDragResult a);                        \
1400     bool base_##CBNAME(wxDragResult a);
1401
1402
1403 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \
1404     bool CLASS::CBNAME(wxDragResult a) {                                \
1405         bool rval=FALSE;                                                \
1406         bool found;                                                     \
1407         wxPyBeginBlockThreads();                                        \
1408         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))          \
1409             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));\
1410         wxPyEndBlockThreads();                                          \
1411         if (! found)                                                    \
1412             rval = PCLASS::CBNAME(a);                                   \
1413         return rval;                                                    \
1414     }                                                                   \
1415     bool CLASS::base_##CBNAME(wxDragResult a) {                         \
1416         return PCLASS::CBNAME(a);                                       \
1417     }
1418
1419 //---------------------------------------------------------------------------
1420
1421 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME)   \
1422     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);
1423
1424
1425 #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)            \
1426     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
1427         wxPyBeginBlockThreads();                                        \
1428         int rval=0;                                                     \
1429         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                    \
1430             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1431         wxPyEndBlockThreads();                                          \
1432         return (wxDragResult)rval;                                      \
1433     }                                                                   \
1434
1435 //---------------------------------------------------------------------------
1436
1437 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \
1438     bool CBNAME(int a, int b, const wxString& c);
1439
1440 #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
1441     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
1442         bool rval=FALSE;                                                \
1443         wxPyBeginBlockThreads();                                        \
1444         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                  \
1445             PyObject* s = wx2PyString(c);                               \
1446             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1447             Py_DECREF(s);                                               \
1448         }                                                               \
1449         wxPyEndBlockThreads();                                          \
1450         return rval;                                                    \
1451     }                                                                   \
1452
1453 //---------------------------------------------------------------------------
1454
1455 #define DEC_PYCALLBACK_SIZET_(CBNAME)                  \
1456     size_t CBNAME();                                   \
1457     size_t base_##CBNAME();
1458
1459
1460 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
1461     size_t CLASS::CBNAME() {                                                    \
1462         size_t rval=0;                                                          \
1463         bool found;                                                             \
1464         wxPyBeginBlockThreads();                                                \
1465         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
1466             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
1467         wxPyEndBlockThreads();                                                  \
1468         if (! found)                                                            \
1469             rval = PCLASS::CBNAME();                                            \
1470         return rval;                                                            \
1471     }                                                                           \
1472     size_t CLASS::base_##CBNAME() {                                             \
1473         return PCLASS::CBNAME();                                                \
1474     }
1475
1476 //---------------------------------------------------------------------------
1477
1478 #define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME)                                    \
1479     wxDataFormat  CBNAME(size_t a);                                             \
1480     wxDataFormat  base_##CBNAME(size_t a);
1481
1482
1483 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
1484     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
1485         wxDataFormat rval=0;                                                    \
1486         bool found;                                                             \
1487         wxPyBeginBlockThreads();                                                \
1488         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1489             PyObject* ro;                                                       \
1490             wxDataFormat* ptr;                                                  \
1491             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \
1492             if (ro) {                                                           \
1493                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxDataFormat_p"))     \
1494                     rval = *ptr;                                                \
1495                 Py_DECREF(ro);                                                  \
1496             }                                                                   \
1497         }                                                                       \
1498         wxPyEndBlockThreads();                                                  \
1499         if (! found)                                                            \
1500             rval = PCLASS::CBNAME(a);                                           \
1501         return rval;                                                            \
1502     }                                                                           \
1503     wxDataFormat  CLASS::base_##CBNAME(size_t a) {                              \
1504         return PCLASS::CBNAME(a);                                               \
1505     }
1506
1507 //---------------------------------------------------------------------------
1508
1509 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
1510     void CBNAME(const Type& a);                         \
1511     void base_##CBNAME(const Type& a);
1512
1513
1514 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)                   \
1515     void CLASS::CBNAME(const Type& a) {                                         \
1516         bool found;                                                             \
1517         wxPyBeginBlockThreads();                                                \
1518         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1519             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
1520             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
1521             Py_DECREF(obj);                                                     \
1522         }                                                                       \
1523         wxPyEndBlockThreads();                                                  \
1524         if (! found)                                                            \
1525             PCLASS::CBNAME(a);                                                  \
1526     }                                                                           \
1527     void CLASS::base_##CBNAME(const Type& a) {                                  \
1528         PCLASS::CBNAME(a);                                                      \
1529     }
1530
1531
1532 //---------------------------------------------------------------------------
1533
1534 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
1535     void CBNAME(Type& a);                          \
1536     void base_##CBNAME(Type& a);
1537
1538
1539 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                        \
1540     void CLASS::CBNAME(Type& a) {                                               \
1541         bool found;                                                             \
1542         wxPyBeginBlockThreads();                                                \
1543         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1544             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
1545             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));          \
1546             Py_DECREF(obj);                                                     \
1547         }                                                                       \
1548         wxPyEndBlockThreads();                                                  \
1549         if (! found)                                                            \
1550             PCLASS::CBNAME(a);                                                  \
1551     }                                                                           \
1552     void CLASS::base_##CBNAME(Type& a) {                                        \
1553         PCLASS::CBNAME(a);                                                      \
1554     }
1555
1556 //---------------------------------------------------------------------------
1557
1558 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
1559     bool CBNAME(Type& a);                               \
1560     bool base_##CBNAME(Type& a);
1561
1562
1563 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)                    \
1564     bool CLASS::CBNAME(Type& a) {                                               \
1565         bool rv=FALSE;                                                          \
1566         bool found;                                                             \
1567         wxPyBeginBlockThreads();                                                \
1568         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1569             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);           \
1570             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));     \
1571             Py_DECREF(obj);                                                     \
1572         }                                                                       \
1573         wxPyEndBlockThreads();                                                  \
1574         if (! found)                                                            \
1575             rv = PCLASS::CBNAME(a);                                             \
1576         return rv;                                                              \
1577     }                                                                           \
1578     bool CLASS::base_##CBNAME(Type& a) {                                        \
1579         return PCLASS::CBNAME(a);                                               \
1580     }
1581
1582 //---------------------------------------------------------------------------
1583
1584 #define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME)                                  \
1585     wxString CBNAME(long a, long b) const;                                      \
1586     wxString base_##CBNAME(long a, long b)const ;
1587
1588 #define IMP_PYCALLBACK_STRING_LONGLONG(CLASS, PCLASS, CBNAME)                   \
1589     wxString CLASS::CBNAME(long a, long b) const {                              \
1590         wxString rval;                                                          \
1591         bool found;                                                             \
1592         wxPyBeginBlockThreads();                                                \
1593         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1594             PyObject* ro;                                                       \
1595             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b));  \
1596             if (ro) {                                                           \
1597                 rval = Py2wxString(ro);                                         \
1598                 Py_DECREF(ro);                                                  \
1599             }                                                                   \
1600         }                                                                       \
1601         wxPyEndBlockThreads();                                                  \
1602         if (! found)                                                            \
1603             rval = PCLASS::CBNAME(a,b);                                         \
1604         return rval;                                                            \
1605     }                                                                           \
1606     wxString CLASS::base_##CBNAME(long a, long b) const {                       \
1607         return PCLASS::CBNAME(a,b);                                             \
1608     }
1609
1610 //---------------------------------------------------------------------------
1611
1612 #define DEC_PYCALLBACK_INT_LONG(CBNAME)                                         \
1613     int CBNAME(long a) const;                                                   \
1614     int base_##CBNAME(long a)const ;
1615
1616
1617 #define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME)                          \
1618     int CLASS::CBNAME(long a) const {                                           \
1619         int rval=-1;                                                            \
1620         bool found;                                                             \
1621         wxPyBeginBlockThreads();                                                \
1622         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1623             PyObject* ro;                                                       \
1624             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a));     \
1625             if (ro) {                                                           \
1626                 rval = PyInt_AsLong(ro);                                        \
1627                 Py_DECREF(ro);                                                  \
1628             }                                                                   \
1629         }                                                                       \
1630         wxPyEndBlockThreads();                                                  \
1631         if (! found)                                                            \
1632             rval = PCLASS::CBNAME(a);                                           \
1633         return rval;                                                            \
1634     }                                                                           \
1635     int CLASS::base_##CBNAME(long a) const {                                    \
1636         return PCLASS::CBNAME(a);                                               \
1637     }
1638
1639
1640 //---------------------------------------------------------------------------
1641
1642 #define DEC_PYCALLBACK_LISTATTR_LONG(CBNAME)                                    \
1643     wxListItemAttr*  CBNAME(long a) const;                                      \
1644     wxListItemAttr*  base_##CBNAME(long a);
1645
1646
1647 #define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME)                     \
1648     wxListItemAttr *CLASS::CBNAME(long a) const {                               \
1649         wxListItemAttr *rval = NULL;                                            \
1650         bool found;                                                             \
1651         wxPyBeginBlockThreads();                                                \
1652         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1653             PyObject* ro;                                                       \
1654             wxListItemAttr* ptr;                                                \
1655             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));    \
1656             if (ro) {                                                           \
1657                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxListItemAttr_p"))   \
1658                     rval = ptr;                                                 \
1659                 Py_DECREF(ro);                                                  \
1660             }                                                                   \
1661         }                                                                       \
1662         wxPyEndBlockThreads();                                                  \
1663         if (! found)                                                            \
1664             rval = PCLASS::CBNAME(a);                                           \
1665         return rval;                                                            \
1666     }                                                                           \
1667     wxListItemAttr *CLASS::base_##CBNAME(long a) {                              \
1668         return PCLASS::CBNAME(a);                                               \
1669     }
1670
1671 //---------------------------------------------------------------------------
1672
1673 #define DEC_PYCALLBACK_BOOL_ME(CBNAME)                                          \
1674     bool CBNAME(wxMouseEvent& e);                                               \
1675     bool base_##CBNAME(wxMouseEvent& e);
1676
1677 #define IMP_PYCALLBACK_BOOL_ME(CLASS, PCLASS, CBNAME)                           \
1678     bool CLASS::CBNAME(wxMouseEvent& e) {                                       \
1679         bool rval=FALSE;                                                        \
1680         bool found;                                                             \
1681         wxPyBeginBlockThreads();                                                \
1682         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
1683             PyObject* ro;                                                       \
1684             PyObject* obj  = wxPyConstructObject((void*)&e, "wxMouseEvent", 0); \
1685             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj));   \
1686             if (ro) {                                                           \
1687                 rval = PyInt_AsLong(ro);                                        \
1688                 Py_DECREF(ro);                                                  \
1689             }                                                                   \
1690             Py_DECREF(obj);                                                     \
1691         }                                                                       \
1692         wxPyEndBlockThreads();                                                  \
1693         if (! found)                                                            \
1694             return PCLASS::CBNAME(e);                                           \
1695         return rval;                                                            \
1696     }                                                                           \
1697     bool CLASS::base_##CBNAME(wxMouseEvent& e) {                                \
1698         return PCLASS::CBNAME(e);                                               \
1699     }
1700
1701
1702 //---------------------------------------------------------------------------
1703
1704 #endif