wxPython/src/helpers.h

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        helpers.h
   3 // Purpose:     Helper functions/classes for the wxPython extenaion module
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7/1/97
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifndef __wxp_helpers__
  14 #define __wxp_helpers__
  15
  16 #include <wx/wx.h>
  17
  18 //----------------------------------------------------------------------
  19
  20 // if we want to handle threads and Python threads are available...
  21 #if defined(WXP_USE_THREAD) && defined(WITH_THREAD)
  22
  23 #define WXP_WITH_THREAD
  24 #define wxPy_BEGIN_ALLOW_THREADS  Py_BEGIN_ALLOW_THREADS
  25 #define wxPy_END_ALLOW_THREADS    Py_END_ALLOW_THREADS
  26
  27 #else  // no Python threads...
  28 #undef WXP_WITH_THREAD
  29 #define wxPy_BEGIN_ALLOW_THREADS
  30 #define wxPy_END_ALLOW_THREADS
  31 #endif
  32
  33
  34 //---------------------------------------------------------------------------
  35
  36 typedef unsigned char byte;
  37
  38
  39 class wxPyApp: public wxApp
  40 {
  41 public:
  42     wxPyApp();
  43     ~wxPyApp();
  44     int  MainLoop(void);
  45     bool OnInit(void);
  46 };
  47 extern wxPyApp *wxPythonApp;
  48
  49 //----------------------------------------------------------------------
  50
  51 void      __wxPreStart();
  52 PyObject* __wxStart(PyObject*, PyObject* args);
  53 void      __wxCleanup();
  54
  55 extern PyObject* wxPython_dict;
  56 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
  57
  58 void wxPyEventThunker(wxObject*, wxEvent& event);
  59
  60 PyObject* wxPyConstructObject(void* ptr,
  61                               const char* className,
  62                               int setThisOwn=0);
  63 bool wxPyRestoreThread();
  64 void wxPySaveThread(bool doSave);
  65 PyObject* wxPy_ConvertList(wxListBase* list, const char* className);
  66 long wxPyGetWinHandle(wxWindow* win);
  67
  68
  69
  70 //----------------------------------------------------------------------
  71 // Handle wxInputStreams by Joerg Baumann
  72 // See stream.i for implementations
  73
  74 // list class for return list of strings, e.g. readlines()
  75 WX_DECLARE_LIST(wxString, wxStringPtrList);
  76
  77
  78 // C++ class wxPyInputStream to act as base for python class wxInputStream
  79 // Use it in python like a python file object
  80 class wxPyInputStream {
  81 public:
  82     // underlying wxInputStream
  83     wxInputStream* wxi;
  84
  85 public:
  86     wxPyInputStream(wxInputStream* wxi_) : wxi(wxi_) {}
  87     ~wxPyInputStream();
  88
  89     // python file object interface for input files (most of it)
  90     void close();
  91     void flush();
  92     bool eof();
  93     wxString* read(int size=-1);
  94     wxString* readline(int size=-1);
  95     wxStringPtrList* readlines(int sizehint=-1);
  96     void seek(int offset, int whence=0);
  97     int tell();
  98     /*
  99       bool isatty();
 100       int fileno();
 101       void truncate(int size=-1);
 102       void write(wxString data);
 103       void writelines(wxStringPtrList);
 104     */
 105 };
 106
 107
 108 //----------------------------------------------------------------------
 109 // These are helpers used by the typemaps
 110
 111 byte* byte_LIST_helper(PyObject* source);
 112 int* int_LIST_helper(PyObject* source);
 113 long* long_LIST_helper(PyObject* source);
 114 char** string_LIST_helper(PyObject* source);
 115 wxPoint* wxPoint_LIST_helper(PyObject* source);
 116 wxBitmap** wxBitmap_LIST_helper(PyObject* source);
 117 wxString* wxString_LIST_helper(PyObject* source);
 118 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
 119
 120 bool wxSize_helper(PyObject* source, wxSize** obj);
 121 bool wxPoint_helper(PyObject* source, wxPoint** obj);
 122 bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
 123 bool wxRect_helper(PyObject* source, wxRect** obj);
 124 bool wxColour_helper(PyObject* source, wxColour** obj);
 125
 126 //----------------------------------------------------------------------
 127
 128 #ifndef SWIGCODE
 129 extern "C" void SWIG_MakePtr(char *, void *, char *);
 130 extern "C" char *SWIG_GetPtr(char *, void **, char *);
 131 extern "C" char *SWIG_GetPtrObj(PyObject *obj, void **ptr, char *type);
 132 #endif
 133
 134
 135 #ifdef _MSC_VER
 136 # pragma warning(disable:4800)
 137 # pragma warning(disable:4190)
 138 #endif
 139
 140
 141
 142 // Non-const versions to keep SWIG happy.
 143 //  extern wxPoint  wxPyDefaultPosition;
 144 //  extern wxSize   wxPyDefaultSize;
 145 //  extern wxString wxPyEmptyStr;
 146
 147 //----------------------------------------------------------------------
 148
 149 class wxPyCallback : public wxObject {
 150     DECLARE_ABSTRACT_CLASS(wxPyCallback);
 151 public:
 152     wxPyCallback(PyObject* func);
 153     wxPyCallback(const wxPyCallback& other);
 154     ~wxPyCallback();
 155
 156     void EventThunker(wxEvent& event);
 157
 158     PyObject*   m_func;
 159 };
 160
 161 //---------------------------------------------------------------------------
 162
 163 class wxPyTimer : public wxTimer {
 164 public:
 165     wxPyTimer(PyObject* callback);
 166     ~wxPyTimer();
 167
 168     void        Notify();
 169
 170 private:
 171     PyObject*   func;
 172 };
 173
 174 //---------------------------------------------------------------------------
 175 //---------------------------------------------------------------------------
 176 // These Event classes can be derived from in Python and passed through the
 177 // event system without loosing anything.  They do this by keeping a reference
 178 // to themselves and some special case handling in wxPyCallback::EventThunker.
 179
 180
 181 class wxPyEvtSelfRef {
 182 public:
 183     wxPyEvtSelfRef();
 184     ~wxPyEvtSelfRef();
 185
 186     void SetSelf(PyObject* self, bool clone=FALSE);
 187     PyObject* GetSelf() const;
 188
 189 protected:
 190     PyObject*   m_self;
 191     bool        m_cloned;
 192 };
 193
 194
 195 class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
 196     DECLARE_DYNAMIC_CLASS(wxPyEvent)
 197 public:
 198     wxPyEvent(int id=0);
 199     ~wxPyEvent();
 200
 201     void CopyObject(wxObject& dest) const;
 202 };
 203
 204
 205 class wxPyCommandEvent : public wxCommandEvent, public wxPyEvtSelfRef {
 206     DECLARE_DYNAMIC_CLASS(wxPyCommandEvent)
 207 public:
 208     wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0);
 209     ~wxPyCommandEvent();
 210
 211     void CopyObject(wxObject& dest) const;
 212 };
 213
 214
 215 //---------------------------------------------------------------------------
 216 // Export a C API in a struct.  Other modules will be able to load this from
 217 // the wxc module and will then have safe access to these functions, even if
 218 // in another shared library.
 219
 220 class wxPyCallbackHelper;
 221
 222 struct wxPyCoreAPI {
 223
 224     void        (*p_SWIG_MakePtr)(char*, void*, char*);
 225     char*       (*p_SWIG_GetPtr)(char*, void**, char*);
 226     char*       (*p_SWIG_GetPtrObj)(PyObject*, void**, char*);
 227     void        (*p_SWIG_RegisterMapping)(char*, char*, void *(*cast)(void *));
 228     void        (*p_SWIG_addvarlink)(PyObject*, char*, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p));
 229     PyObject*   (*p_SWIG_newvarlink)(void);
 230
 231     void        (*p_wxPySaveThread)(bool);
 232     bool        (*p_wxPyRestoreThread)();
 233     PyObject*   (*p_wxPyConstructObject)(void *, const char *, int);
 234     PyObject*   (*p_wxPy_ConvertList)(wxListBase* list, const char* className);
 235
 236     byte*       (*p_byte_LIST_helper)(PyObject* source);
 237     int*        (*p_int_LIST_helper)(PyObject* source);
 238     long*       (*p_long_LIST_helper)(PyObject* source);
 239     char**      (*p_string_LIST_helper)(PyObject* source);
 240     wxPoint*    (*p_wxPoint_LIST_helper)(PyObject* source);
 241     wxBitmap**  (*p_wxBitmap_LIST_helper)(PyObject* source);
 242     wxString*   (*p_wxString_LIST_helper)(PyObject* source);
 243     wxAcceleratorEntry*   (*p_wxAcceleratorEntry_LIST_helper)(PyObject* source);
 244
 245     bool        (*p_wxSize_helper)(PyObject* source, wxSize** obj);
 246     bool        (*p_wxPoint_helper)(PyObject* source, wxPoint** obj);
 247     bool        (*p_wxRealPoint_helper)(PyObject* source, wxRealPoint** obj);
 248     bool        (*p_wxRect_helper)(PyObject* source, wxRect** obj);
 249     bool        (*p_wxColour_helper)(PyObject* source, wxColour** obj);
 250
 251     void        (*p_wxPyCBH_setSelf)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
 252     bool        (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
 253     int         (*p_wxPyCBH_callCallback)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 254     PyObject*   (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 255     void        (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
 256
 257 };
 258
 259 #ifdef wxPyUSE_EXPORT
 260 static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;  // Each module needs one, but may not use it.
 261 #endif
 262
 263 //---------------------------------------------------------------------------
 264 // This class holds an instance of a Python Shadow Class object and assists
 265 // with looking up and invoking Python callback methods from C++ virtual
 266 // method redirections.  For all classes which have virtuals which should be
 267 // overridable in wxPython, a new subclass is created that contains a
 268 // wxPyCallbackHelper.
 269 //
 270
 271 class wxPyCallbackHelper {
 272 public:
 273     wxPyCallbackHelper(const wxPyCallbackHelper& other);
 274
 275     wxPyCallbackHelper() {
 276         m_class = NULL;
 277         m_self = NULL;
 278         m_lastFound = NULL;
 279         m_incRef = FALSE;
 280     }
 281
 282     ~wxPyCallbackHelper() {
 283 #ifdef wxPyUSE_EXPORT
 284         wxPyCoreAPIPtr->p_wxPyCBH_delete(this);
 285 #else
 286         wxPyCBH_delete(this);
 287 #endif
 288     }
 289
 290     void        setSelf(PyObject* self, PyObject* klass, int incref=TRUE);
 291     bool        findCallback(const char* name) const;
 292     int         callCallback(PyObject* argTuple) const;
 293     PyObject*   callCallbackObj(PyObject* argTuple) const;
 294
 295 private:
 296     PyObject*   m_self;
 297     PyObject*   m_class;
 298     PyObject*   m_lastFound;
 299     int         m_incRef;
 300
 301     friend      void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 302 };
 303
 304
 305 void wxPyCBH_setSelf(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
 306 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name);
 307 int  wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 308 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
 309 void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 310
 311
 312
 313 //----------------------------------------------------------------------
 314
 315 class wxPyUserData : public wxObject {
 316 public:
 317     wxPyUserData(PyObject* obj) {
 318         m_obj = obj;
 319         Py_INCREF(m_obj);
 320     }
 321
 322     ~wxPyUserData() {
 323         bool doSave;
 324 #ifdef wxPyUSE_EXPORT
 325         doSave = wxPyCoreAPIPtr->p_wxPyRestoreThread();
 326         Py_DECREF(m_obj);
 327         wxPyCoreAPIPtr->p_wxPySaveThread(doSave);
 328 #else
 329         doSave = wxPyRestoreThread();
 330         Py_DECREF(m_obj);
 331         wxPySaveThread(doSave);
 332 #endif
 333     }
 334     PyObject* m_obj;
 335 };
 336
 337
 338
 339 //---------------------------------------------------------------------------
 340 // These macros are used to implement the virtual methods that should
 341 // redirect to a Python method if one exists.  The names designate the
 342 // return type, if any, as well as any parameter types.
 343 //---------------------------------------------------------------------------
 344
 345 #define PYPRIVATE                                                       \
 346     void _setSelf(PyObject* self, PyObject* _class, int incref=1) {     \
 347         wxPyCBH_setSelf(m_myInst, self, _class, incref);                \
 348     }                                                                   \
 349     private: wxPyCallbackHelper m_myInst
 350
 351 //---------------------------------------------------------------------------
 352
 353 #define DEC_PYCALLBACK__(CBNAME)                        \
 354     void CBNAME();                                      \
 355     void base_##CBNAME();
 356
 357
 358 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)         \
 359     void CLASS::CBNAME() {                              \
 360         bool doSave = wxPyRestoreThread();              \
 361         if (wxPyCBH_findCallback(m_myInst, #CBNAME))             \
 362             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
 363         else                                            \
 364             PCLASS::CBNAME();                           \
 365         wxPySaveThread(doSave);                         \
 366     }                                                   \
 367     void CLASS::base_##CBNAME() {                       \
 368         PCLASS::CBNAME();                               \
 369     }
 370
 371 //---------------------------------------------------------------------------
 372
 373 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
 374     bool CBNAME(int a, int b);                                  \
 375     bool base_##CBNAME(int a, int b);
 376
 377
 378 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
 379     bool CLASS::CBNAME(int a, int b) {                                  \
 380         bool rval;                                                      \
 381         bool doSave = wxPyRestoreThread();                              \
 382         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
 383             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));    \
 384         else                                                            \
 385             rval = PCLASS::CBNAME(a,b);                                 \
 386         wxPySaveThread(doSave);                                         \
 387         return rval;                                                    \
 388     }                                                                   \
 389     bool CLASS::base_##CBNAME(int a, int b) {                           \
 390         return PCLASS::CBNAME(a,b);                                     \
 391     }
 392
 393 //---------------------------------------------------------------------------
 394
 395 #define DEC_PYCALLBACK_VOID_INTINT(CBNAME)                      \
 396     void CBNAME(int a, int b);                                  \
 397     void base_##CBNAME(int a, int b);
 398
 399
 400 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME)               \
 401     void CLASS::CBNAME(int a, int b) {                                  \
 402         bool doSave = wxPyRestoreThread();                              \
 403         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
 404             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));           \
 405         else                                                            \
 406             PCLASS::CBNAME(a,b);                                        \
 407         wxPySaveThread(doSave);                                         \
 408     }                                                                   \
 409     void CLASS::base_##CBNAME(int a, int b) {                           \
 410         PCLASS::CBNAME(a,b);                                            \
 411     }
 412
 413 //---------------------------------------------------------------------------
 414
 415 #define DEC_PYCALLBACK_BOOL_INT(CBNAME)                         \
 416     bool CBNAME(int a);                                         \
 417     bool base_##CBNAME(int a);
 418
 419
 420 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
 421     bool CLASS::CBNAME(int a) {                                         \
 422         bool rval;                                                      \
 423         bool doSave = wxPyRestoreThread();                              \
 424         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
 425             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
 426         else                                                            \
 427             rval = PCLASS::CBNAME(a);                                   \
 428         wxPySaveThread(doSave);                                         \
 429         return rval;                                                    \
 430     }                                                                   \
 431     bool CLASS::base_##CBNAME(int a) {                                  \
 432         return PCLASS::CBNAME(a);                                       \
 433     }
 434
 435 //---------------------------------------------------------------------------
 436
 437 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \
 438     bool CBNAME(int a);
 439
 440
 441 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
 442     bool CLASS::CBNAME(int a) {                                         \
 443         bool rval;                                                      \
 444         bool doSave = wxPyRestoreThread();                              \
 445         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
 446             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));       \
 447         else rval = FALSE;                                              \
 448         wxPySaveThread(doSave);                                         \
 449         return rval;                                                    \
 450     }
 451
 452
 453 //---------------------------------------------------------------------------
 454
 455 #define DEC_PYCALLBACK__DC(CBNAME)                      \
 456     void CBNAME(wxDC& a);                               \
 457     void base_##CBNAME(wxDC& a);
 458
 459
 460 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)               \
 461     void CLASS::CBNAME(wxDC& a) {                               \
 462         bool doSave = wxPyRestoreThread();                      \
 463         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                   \
 464             PyObject* obj = wxPyConstructObject(&a, "wxDC", 0); \
 465             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));   \
 466             Py_DECREF(obj);                                     \
 467         }                                                       \
 468         else                                                    \
 469             PCLASS::CBNAME(a);                                  \
 470         wxPySaveThread(doSave);                                 \
 471     }                                                           \
 472     void CLASS::base_##CBNAME(wxDC& a) {                        \
 473         PCLASS::CBNAME(a);                                      \
 474     }
 475
 476
 477
 478 //---------------------------------------------------------------------------
 479
 480 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 481     void CBNAME(wxDC& a, bool b);                       \
 482     void base_##CBNAME(wxDC& a, bool b);
 483
 484
 485 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 486     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 487         bool doSave = wxPyRestoreThread();                              \
 488         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
 489             PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);         \
 490             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
 491             Py_DECREF(obj);                                             \
 492         }                                                               \
 493         else                                                            \
 494             PCLASS::CBNAME(a, b);                                       \
 495         wxPySaveThread(doSave);                                         \
 496     }                                                                   \
 497     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 498         PCLASS::CBNAME(a, b);                                           \
 499     }
 500
 501 //---------------------------------------------------------------------------
 502
 503 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
 504     void CBNAME(wxDC& a, bool b);                               \
 505     void base_##CBNAME(wxDC& a, bool b);
 506
 507
 508 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 509     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 510         bool doSave = wxPyRestoreThread();                              \
 511         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
 512             PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);         \
 513             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
 514             Py_DECREF(obj);                                             \
 515         }                                                               \
 516         else                                                            \
 517             PCLASS::CBNAME(a, b);                                       \
 518                 wxPySaveThread(doSave);                                 \
 519     }                                                                   \
 520     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 521         PCLASS::CBNAME(a, b);                                           \
 522     }
 523
 524 //---------------------------------------------------------------------------
 525
 526 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
 527     void CBNAME(double a, double b);                    \
 528     void base_##CBNAME(double a, double b);
 529
 530
 531 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)             \
 532     void CLASS::CBNAME(double a, double b) {                    \
 533         bool doSave = wxPyRestoreThread();                      \
 534         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                     \
 535             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b));   \
 536         else                                                    \
 537             PCLASS::CBNAME(a, b);                               \
 538         wxPySaveThread(doSave);                                 \
 539     }                                                           \
 540     void CLASS::base_##CBNAME(double a, double b) {             \
 541         PCLASS::CBNAME(a, b);                                   \
 542     }
 543
 544 //---------------------------------------------------------------------------
 545
 546 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
 547     void CBNAME(double a, double b, int c, int d);              \
 548     void base_##CBNAME(double a, double b, int c, int d);
 549
 550
 551 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 552     void CLASS::CBNAME(double a, double b, int c, int d) {              \
 553         bool doSave = wxPyRestoreThread();                              \
 554         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
 555             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)",               \
 556                                                        a,b,c,d));       \
 557         else                                                            \
 558             PCLASS::CBNAME(a, b, c, d);                                 \
 559         wxPySaveThread(doSave);                                         \
 560     }                                                                   \
 561     void CLASS::base_##CBNAME(double a, double b, int c, int d) {       \
 562         PCLASS::CBNAME(a, b, c, d);                                     \
 563     }
 564
 565 //---------------------------------------------------------------------------
 566
 567 #define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME)                              \
 568     void CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 569     void base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 570
 571
 572 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
 573     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 574         bool doSave = wxPyRestoreThread();                                              \
 575         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                           \
 576             PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);                         \
 577             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));  \
 578             Py_DECREF(obj);                                                             \
 579         }                                                                               \
 580         else                                                                            \
 581             PCLASS::CBNAME(a, b, c, d, e, f);                                           \
 582         wxPySaveThread(doSave);                                                         \
 583     }                                                                                   \
 584     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 585         PCLASS::CBNAME(a, b, c, d, e, f);                                               \
 586     }
 587
 588 //---------------------------------------------------------------------------
 589
 590 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
 591     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 592     bool base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 593
 594
 595 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
 596     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 597         bool doSave = wxPyRestoreThread();                                              \
 598         bool rval;                                                                      \
 599         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                           \
 600             PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);                         \
 601             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
 602             Py_DECREF(obj);                                                             \
 603         }                                                                               \
 604         else                                                                            \
 605             rval = PCLASS::CBNAME(a, b, c, d, e, f);                                    \
 606         wxPySaveThread(doSave);                                                         \
 607         return rval;                                                                    \
 608     }                                                                                   \
 609     bool CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 610         return PCLASS::CBNAME(a, b, c, d, e, f);                                        \
 611     }
 612
 613 //---------------------------------------------------------------------------
 614
 615 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
 616     void CBNAME(bool a, double b, double c, int d, int e);              \
 617     void base_##CBNAME(bool a, double b, double c, int d, int e);
 618
 619
 620 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 621     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
 622         bool doSave = wxPyRestoreThread();                                      \
 623         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
 624             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(idii)",                       \
 625                                                 (int)a,b,c,d,e));               \
 626         else                                                                    \
 627             PCLASS::CBNAME(a, b, c, d, e);                                      \
 628         wxPySaveThread(doSave);                                                 \
 629     }                                                                           \
 630     void CLASS::base_##CBNAME(bool a, double b, double c, int d, int e) {       \
 631         PCLASS::CBNAME(a, b, c, d, e);                                          \
 632     }
 633
 634 //---------------------------------------------------------------------------
 635
 636 #define DEC_PYCALLBACK__DC4DBL(CBNAME)                                      \
 637     void CBNAME(wxDC& a, double b, double c, double d, double e);               \
 638     void base_##CBNAME(wxDC& a, double b, double c, double d, double e);
 639
 640
 641 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
 642     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
 643         bool doSave = wxPyRestoreThread();                                      \
 644         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 645             PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);                 \
 646             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e));   \
 647             Py_DECREF(obj);                                                     \
 648         }                                                                       \
 649         else                                                                    \
 650             PCLASS::CBNAME(a, b, c, d, e);                                      \
 651         wxPySaveThread(doSave);                                                 \
 652     }                                                                           \
 653     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e) {\
 654         PCLASS::CBNAME(a, b, c, d, e);                                          \
 655     }
 656
 657 //---------------------------------------------------------------------------
 658
 659 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 660     void CBNAME(wxDC& a, bool b);                       \
 661     void base_##CBNAME(wxDC& a, bool b);
 662
 663
 664 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 665     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 666         bool doSave = wxPyRestoreThread();                              \
 667         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
 668             PyObject* obj = wxPyConstructObject(&a, "wxDC", 0);         \
 669             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b));  \
 670             Py_DECREF(obj);                                             \
 671         }                                                               \
 672         else                                                            \
 673             PCLASS::CBNAME(a, b);                                       \
 674         wxPySaveThread(doSave);                                         \
 675     }                                                                   \
 676     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 677         PCLASS::CBNAME(a, b);                                           \
 678     }
 679
 680 //---------------------------------------------------------------------------
 681
 682 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
 683     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \
 684     void base_##CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);
 685
 686
 687 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 688     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
 689                 int e, int f) {                                                 \
 690         bool doSave = wxPyRestoreThread();                                      \
 691         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 692             PyObject* obj = wxPyConstructObject(a, "wxPyControlPoint", 0);      \
 693             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
 694             Py_DECREF(obj);                                                     \
 695         }                                                                       \
 696         else                                                                    \
 697             PCLASS::CBNAME(a, b, c, d, e, f);                                   \
 698         wxPySaveThread(doSave);                                                 \
 699     }                                                                           \
 700     void CLASS::base_##CBNAME(wxControlPoint* a, bool b, double c, double d,    \
 701                        int e, int f) {                                          \
 702         PCLASS::CBNAME(a, b, c, d, e, f);                                       \
 703     }
 704
 705 //---------------------------------------------------------------------------
 706
 707 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
 708     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \
 709     void base_##CBNAME(wxControlPoint* a, double b, double c, int d, int e);
 710
 711
 712 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 713     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
 714         bool doSave = wxPyRestoreThread();                                      \
 715         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 716             PyObject* obj = wxPyConstructObject(a, "wxPyControlPoint", 0);      \
 717             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e));   \
 718             Py_DECREF(obj);                                                     \
 719         }                                                                       \
 720         else                                                                    \
 721             PCLASS::CBNAME(a, b, c, d, e);                                      \
 722         wxPySaveThread(doSave);                                                 \
 723     }                                                                           \
 724     void CLASS::base_##CBNAME(wxControlPoint* a, double b, double c,            \
 725                        int d, int e) {                                          \
 726         PCLASS::CBNAME(a, b, c, d, e);                                          \
 727     }
 728
 729 //---------------------------------------------------------------------------
 730
 731 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
 732     void CBNAME(double a, double b, int c);             \
 733     void base_##CBNAME(double a, double b, int c);
 734
 735
 736 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                  \
 737     void CLASS::CBNAME(double a, double b, int c) {                     \
 738         bool doSave = wxPyRestoreThread();                              \
 739         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
 740             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c));       \
 741         else                                                            \
 742             PCLASS::CBNAME(a, b, c);                                    \
 743         wxPySaveThread(doSave);                                         \
 744     }                                                                   \
 745     void CLASS::base_##CBNAME(double a, double b, int c) {              \
 746         PCLASS::CBNAME(a, b, c);                                        \
 747     }
 748
 749 //---------------------------------------------------------------------------
 750
 751 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
 752     void CBNAME(bool a, double b, double c, int d);             \
 753     void base_##CBNAME(bool a, double b, double c, int d);
 754
 755
 756 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
 757     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
 758         bool doSave = wxPyRestoreThread();                                      \
 759         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
 760             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));       \
 761         else                                                                    \
 762             PCLASS::CBNAME(a, b, c, d);                                         \
 763         wxPySaveThread(doSave);                                                 \
 764     }                                                                           \
 765     void CLASS::base_##CBNAME(bool a, double b, double c, int d) {              \
 766         PCLASS::CBNAME(a, b, c, d);                                             \
 767     }
 768
 769 //---------------------------------------------------------------------------
 770 //---------------------------------------------------------------------------
 771
 772 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
 773     void CBNAME(const wxString& a);                     \
 774     void base_##CBNAME(const wxString& a);
 775
 776
 777 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                   \
 778     void CLASS::CBNAME(const wxString& a)  {                            \
 779         bool doSave = wxPyRestoreThread();                              \
 780         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
 781             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));     \
 782         else                                                            \
 783             PCLASS::CBNAME(a);                                          \
 784         wxPySaveThread(doSave);                                         \
 785     }                                                                   \
 786     void CLASS::base_##CBNAME(const wxString& a) {                      \
 787         PCLASS::CBNAME(a);                                              \
 788     }
 789
 790 //---------------------------------------------------------------------------
 791
 792 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
 793     bool CBNAME(const wxString& a);                     \
 794     bool base_##CBNAME(const wxString& a);
 795
 796
 797 #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
 798     bool CLASS::CBNAME(const wxString& a)  {                                    \
 799         bool rval;                                                              \
 800         bool doSave = wxPyRestoreThread();                                      \
 801         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
 802             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));      \
 803         else                                                                    \
 804             rval = PCLASS::CBNAME(a);                                           \
 805         wxPySaveThread(doSave);                                                 \
 806         return rval;                                                            \
 807     }                                                                           \
 808     bool CLASS::base_##CBNAME(const wxString& a) {                              \
 809         return PCLASS::CBNAME(a);                                               \
 810     }
 811
 812 //---------------------------------------------------------------------------
 813
 814 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME)         \
 815     bool CBNAME(const wxString& a);
 816                    \
 817 #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME)                  \
 818     bool CLASS::CBNAME(const wxString& a)  {                                    \
 819         bool rval;                                                              \
 820         bool doSave = wxPyRestoreThread();                                      \
 821         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
 822             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(s)", a.c_str()));      \
 823         wxPySaveThread(doSave);                                                 \
 824         return rval;                                                            \
 825     }                                                                           \
 826
 827 //---------------------------------------------------------------------------
 828
 829 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME)                               \
 830     wxString CBNAME(const wxString& a);                                         \
 831
 832 #define IMP_PYCALLBACK_STRING_STRING_pure(CLASS, PCLASS, CBNAME)                \
 833     wxString CLASS::CBNAME(const wxString& a)  {                                \
 834         wxString rval;                                                          \
 835         bool doSave = wxPyRestoreThread();                                      \
 836         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 837             PyObject* ro;                                                       \
 838             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(s)", a.c_str()));     \
 839             if (ro) {                                                           \
 840                 PyObject* str = PyObject_Str(ro);                               \
 841                 rval = PyString_AsString(str);                                  \
 842                 Py_DECREF(ro);   Py_DECREF(str);                                \
 843             }                                                                   \
 844         }                                                                       \
 845         wxPySaveThread(doSave);                                                 \
 846         return rval;                                                            \
 847     }                                                                           \
 848
 849 //---------------------------------------------------------------------------
 850
 851 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME)                            \
 852     wxString CBNAME(const wxString& a,int b);                                   \
 853
 854 #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME)             \
 855     wxString CLASS::CBNAME(const wxString& a,int b)  {                          \
 856         wxString rval;                                                          \
 857         bool doSave = wxPyRestoreThread();                                      \
 858         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 859             PyObject* ro;                                                       \
 860             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(si)", a.c_str(),b));  \
 861             if (ro) {                                                           \
 862                 PyObject* str = PyObject_Str(ro);                               \
 863                 rval = PyString_AsString(str);                                  \
 864                 Py_DECREF(ro);   Py_DECREF(str);                                \
 865             }                                                                   \
 866         }                                                                       \
 867         wxPySaveThread(doSave);                                                 \
 868         return rval;                                                            \
 869     }                                                                           \
 870
 871 //---------------------------------------------------------------------------
 872
 873 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME)              \
 874     bool CBNAME(const wxString& a, const wxString& b);        \
 875     bool base_##CBNAME(const wxString& a, const wxString& b);
 876
 877
 878 #define IMP_PYCALLBACK_BOOL_STRINGSTRING(CLASS, PCLASS, CBNAME)                 \
 879     bool CLASS::CBNAME(const wxString& a, const wxString& b) {                  \
 880         bool rval;                                                              \
 881         bool doSave = wxPyRestoreThread();                                      \
 882         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
 883             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ss)",                  \
 884                                                        a.c_str(), b.c_str()));  \
 885         else                                                                    \
 886             rval = PCLASS::CBNAME(a, b);                                        \
 887         wxPySaveThread(doSave);                                                 \
 888         return rval;                                                            \
 889     }                                                                           \
 890     bool CLASS::base_##CBNAME(const wxString& a, const wxString& b) {           \
 891         return PCLASS::CBNAME(a, b);                                            \
 892     }
 893
 894 //---------------------------------------------------------------------------
 895
 896 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
 897     wxString CBNAME();                                  \
 898     wxString base_##CBNAME();
 899
 900
 901 #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
 902     wxString CLASS::CBNAME() {                                                  \
 903         wxString rval;                                                          \
 904         bool doSave = wxPyRestoreThread();                                      \
 905         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 906             PyObject* ro;                                                       \
 907             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
 908             if (ro) {                                                           \
 909                 PyObject* str = PyObject_Str(ro);                               \
 910                 rval = PyString_AsString(str);                                  \
 911                 Py_DECREF(ro);  Py_DECREF(str);                                 \
 912             }                                                                   \
 913         }                                                                       \
 914         else                                                                    \
 915             rval = PCLASS::CBNAME();                                            \
 916         wxPySaveThread(doSave);                                                 \
 917         return rval;                                                            \
 918     }                                                                           \
 919     wxString CLASS::base_##CBNAME() {                                           \
 920         return PCLASS::CBNAME();                                                \
 921     }
 922
 923 //---------------------------------------------------------------------------
 924
 925 #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
 926     wxString CBNAME();
 927
 928
 929 #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
 930     wxString CLASS::CBNAME() {                                                  \
 931         wxString rval;                                                          \
 932         bool doSave = wxPyRestoreThread();                                      \
 933         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 934             PyObject* ro;                                                       \
 935             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
 936             if (ro) {                                                           \
 937                 PyObject* str = PyObject_Str(ro);                               \
 938                 rval = PyString_AsString(str);                                  \
 939                 Py_DECREF(ro);   Py_DECREF(str);                                \
 940             }                                                                   \
 941         }                                                                       \
 942         wxPySaveThread(doSave);                                                 \
 943         return rval;                                                            \
 944     }
 945
 946 //---------------------------------------------------------------------------
 947
 948 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \
 949     bool CBNAME(const wxHtmlTag& a);                          \
 950
 951
 952 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
 953     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
 954         bool rval = FALSE;                                                      \
 955         bool doSave = wxPyRestoreThread();                                      \
 956         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 957             PyObject* obj = wxPyConstructObject((void*)&a,"wxHtmlTag", 0);      \
 958             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));            \
 959             Py_DECREF(obj);                                                     \
 960         }                                                                       \
 961         wxPySaveThread(doSave);                                                 \
 962         return rval;                                                            \
 963     }
 964
 965 //---------------------------------------------------------------------------
 966
 967 #define DEC_PYCALLBACK___pure(CBNAME)                         \
 968     void CBNAME();                                            \
 969
 970
 971 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME)                            \
 972     void CLASS::CBNAME() {                                                      \
 973         bool doSave = wxPyRestoreThread();                                      \
 974         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
 975             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                         \
 976         wxPySaveThread(doSave);                                                 \
 977     }
 978
 979 //---------------------------------------------------------------------------
 980
 981 #define DEC_PYCALLBACK_wxSize__pure(CBNAME)                         \
 982     wxSize CBNAME();                                                \
 983
 984
 985 #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME)                      \
 986     wxSize CLASS::CBNAME() {                                                    \
 987         wxSize rval(0,0);                                                       \
 988         bool doSave = wxPyRestoreThread();                                      \
 989         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
 990             PyObject* ro;                                                       \
 991             wxSize*   ptr;                                                      \
 992             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));                 \
 993             if (ro) {                                                           \
 994                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))           \
 995                     rval = *ptr;                                                \
 996                 Py_DECREF(ro);                                                  \
 997             }                                                                   \
 998         }                                                                       \
 999         wxPySaveThread(doSave);                                                 \
1000         return rval;                                                            \
1001     }
1002
1003 //---------------------------------------------------------------------------
1004
1005 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME)                      \
1006     bool CBNAME(wxWindow* a);                                  \
1007     bool base_##CBNAME(wxWindow* a);
1008
1009
1010 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME)                \
1011     bool CLASS::CBNAME(wxWindow* a) {                                   \
1012         bool rval;                                                      \
1013         bool doSave = wxPyRestoreThread();                              \
1014         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
1015             PyObject* obj = wxPyConstructObject((void*)a,"wxWindow", 0);\
1016             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));    \
1017             Py_DECREF(obj);                                             \
1018         }                                                               \
1019         else                                                            \
1020             rval = PCLASS::CBNAME(a);                                   \
1021         wxPySaveThread(doSave);                                         \
1022         return rval;                                                    \
1023     }                                                                   \
1024     bool CLASS::base_##CBNAME(wxWindow* a) {                            \
1025         return PCLASS::CBNAME(a);                                       \
1026     }
1027
1028 //---------------------------------------------------------------------------
1029
1030 #define DEC_PYCALLBACK_BOOL_(CBNAME)                      \
1031     bool CBNAME();                                        \
1032     bool base_##CBNAME();
1033
1034
1035 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME)                     \
1036     bool CLASS::CBNAME() {                                              \
1037         bool rval;                                                      \
1038         bool doSave = wxPyRestoreThread();                              \
1039         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
1040             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));          \
1041         else                                                            \
1042             rval = PCLASS::CBNAME();                                    \
1043         wxPySaveThread(doSave);                                         \
1044         return rval;                                                    \
1045     }                                                                   \
1046     bool CLASS::base_##CBNAME() {                                       \
1047         return PCLASS::CBNAME();                                        \
1048     }
1049
1050 //---------------------------------------------------------------------------
1051
1052 #define DEC_PYCALLBACK_DR_2WXCDR(CBNAME)                 \
1053     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);    \
1054     wxDragResult base_##CBNAME(wxCoord x, wxCoord y, wxDragResult def);
1055
1056
1057 #define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME)                 \
1058     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
1059         bool doSave = wxPyRestoreThread();                              \
1060         int rval;                                                       \
1061         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
1062             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1063         else                                                            \
1064             rval = PCLASS::CBNAME(a, b, c);                             \
1065         wxPySaveThread(doSave);                                         \
1066         return (wxDragResult)rval;                                      \
1067     }                                                                   \
1068     wxDragResult CLASS::base_##CBNAME(wxCoord a, wxCoord b, wxDragResult c) { \
1069         return PCLASS::CBNAME(a, b, c);                                       \
1070     }
1071
1072 //---------------------------------------------------------------------------
1073
1074 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME)                        \
1075     wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location);       \
1076
1077 #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME)         \
1078     wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) {        \
1079         bool doSave = wxPyRestoreThread();                              \
1080         wxFSFile* rval=0;                                               \
1081         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
1082             PyObject* ro;                                               \
1083             PyObject* obj = wxPyConstructObject(&a, "wxFileSystem", 0); \
1084             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Os)",         \
1085                                           obj, b.c_str()));             \
1086             if (ro) {                                                   \
1087                 SWIG_GetPtrObj(ro, (void **)&rval, "_wxFSFILE_p");      \
1088                 Py_DECREF(ro);                                          \
1089             }                                                           \
1090             Py_DECREF(obj);                                             \
1091         }                                                               \
1092         wxPySaveThread(doSave);                                         \
1093         return rval;                                                    \
1094     };
1095
1096 //---------------------------------------------------------------------------
1097
1098 #define DEC_PYCALLBACK_BOOL_DR(CBNAME)                  \
1099     bool CBNAME(wxDragResult a);                        \
1100     bool base_##CBNAME(wxDragResult a);
1101
1102
1103 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME)                   \
1104     bool CLASS::CBNAME(wxDragResult a) {                                \
1105         bool doSave = wxPyRestoreThread();                              \
1106         bool rval;                                                      \
1107         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
1108             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));      \
1109         else                                                            \
1110             rval = PCLASS::CBNAME(a);                                   \
1111         wxPySaveThread(doSave);                                         \
1112         return rval;                                                    \
1113     }                                                                   \
1114     bool CLASS::base_##CBNAME(wxDragResult a) {                         \
1115         return PCLASS::CBNAME(a);                                       \
1116     }
1117
1118 //---------------------------------------------------------------------------
1119
1120 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME)   \
1121     wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def);
1122
1123
1124 #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME)            \
1125     wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) {  \
1126         bool doSave = wxPyRestoreThread();                              \
1127         int rval;                                                       \
1128         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
1129             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1130         wxPySaveThread(doSave);                                         \
1131         return (wxDragResult)rval;                                      \
1132     }                                                                   \
1133
1134 //---------------------------------------------------------------------------
1135
1136 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME)                      \
1137     bool CBNAME(int a, int b, const wxString& c);
1138
1139
1140 #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME)       \
1141     bool CLASS::CBNAME(int a, int b, const wxString& c) {               \
1142         bool rval;                                                      \
1143         bool doSave = wxPyRestoreThread();                              \
1144         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                             \
1145             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
1146         wxPySaveThread(doSave);                                         \
1147         return rval;                                                    \
1148     }                                                                   \
1149
1150 //---------------------------------------------------------------------------
1151
1152 #define DEC_PYCALLBACK_SIZET_(CBNAME)                  \
1153     size_t CBNAME();                                   \
1154     size_t base_##CBNAME();
1155
1156
1157 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME)                            \
1158     size_t CLASS::CBNAME() {                                                    \
1159         size_t rval;                                                            \
1160         bool doSave = wxPyRestoreThread();                                      \
1161         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                                     \
1162             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                  \
1163         else                                                                    \
1164             rval = PCLASS::CBNAME();                                            \
1165         wxPySaveThread(doSave);                                                 \
1166         return rval;                                                            \
1167     }                                                                           \
1168     size_t CLASS::base_##CBNAME() {                                             \
1169         return PCLASS::CBNAME();                                                \
1170     }
1171
1172 //---------------------------------------------------------------------------
1173
1174 #define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME)                  \
1175     wxDataFormat  CBNAME();                                        \
1176     wxDataFormat  base_##CBNAME();
1177
1178
1179 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME)                     \
1180     wxDataFormat CLASS::CBNAME(size_t a) {                                      \
1181         wxDataFormat rval;                                                      \
1182         bool doSave = wxPyRestoreThread();                                      \
1183         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                                   \
1184             PyObject* ro;                                                       \
1185             wxDataFormat* ptr;                                                  \
1186             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a));             \
1187             if (ro) {                                                           \
1188                 if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxDataFormat_p"))     \
1189                     rval = *ptr;                                                \
1190                 Py_DECREF(ro);                                                  \
1191             }                                                                   \
1192         }                                                                       \
1193         else                                                                    \
1194             rval = PCLASS::CBNAME(a);                                           \
1195         wxPySaveThread(doSave);                                                 \
1196         return rval;                                                            \
1197     }                                                                           \
1198     wxDataFormat  CLASS::base_##CBNAME(size_t a) {                              \
1199         return PCLASS::CBNAME(a);                                               \
1200     }
1201
1202 //---------------------------------------------------------------------------
1203
1204 #define DEC_PYCALLBACK__constany(CBNAME, Type)          \
1205     void CBNAME(const Type& a);                         \
1206     void base_##CBNAME(const Type& a);
1207
1208
1209 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type)           \
1210     void CLASS::CBNAME(const Type& a) {                                 \
1211         bool doSave = wxPyRestoreThread();                              \
1212         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
1213             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
1214             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));           \
1215             Py_DECREF(obj);                                             \
1216         }                                                               \
1217         else                                                            \
1218             PCLASS::CBNAME(a);                                          \
1219         wxPySaveThread(doSave);                                         \
1220     }                                                                   \
1221     void CLASS::base_##CBNAME(const Type& a) {                          \
1222         PCLASS::CBNAME(a);                                              \
1223     }
1224
1225
1226 //---------------------------------------------------------------------------
1227
1228 #define DEC_PYCALLBACK__any(CBNAME, Type)          \
1229     void CBNAME(Type& a);                          \
1230     void base_##CBNAME(Type& a);
1231
1232
1233 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type)                \
1234     void CLASS::CBNAME(Type& a) {                                       \
1235         bool doSave = wxPyRestoreThread();                              \
1236         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
1237             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
1238             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));           \
1239             Py_DECREF(obj);                                             \
1240         }                                                               \
1241         else                                                            \
1242             PCLASS::CBNAME(a);                                          \
1243         wxPySaveThread(doSave);                                         \
1244     }                                                                   \
1245     void CLASS::base_##CBNAME(Type& a) {                                \
1246         PCLASS::CBNAME(a);                                              \
1247     }
1248
1249 //---------------------------------------------------------------------------
1250
1251 #define DEC_PYCALLBACK_bool_any(CBNAME, Type)           \
1252     bool CBNAME(Type& a);                               \
1253     bool base_##CBNAME(Type& a);
1254
1255
1256 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type)            \
1257     bool CLASS::CBNAME(Type& a) {                                       \
1258         bool rv;                                                        \
1259         bool doSave = wxPyRestoreThread();                              \
1260         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                           \
1261             PyObject* obj = wxPyConstructObject((void*)&a, #Type, 0);   \
1262             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));      \
1263             Py_DECREF(obj);                                             \
1264         }                                                               \
1265         else                                                            \
1266             rv = PCLASS::CBNAME(a);                                     \
1267         wxPySaveThread(doSave);                                         \
1268         return rv;                                                      \
1269     }                                                                   \
1270     bool CLASS::base_##CBNAME(Type& a) {                                \
1271         return PCLASS::CBNAME(a);                                       \
1272     }
1273
1274 //---------------------------------------------------------------------------
1275
1276 #endif
1277
1278
1279
1280