utils/wxPython/src/helpers.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        helpers.h
   3 // Purpose:     Helper functions/classes for the wxPython extenaion module
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7/1/97
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifndef __wxp_helpers__
  14 #define __wxp_helpers__
  15
  16 #include <wx/wx.h>
  17
  18
  19 //----------------------------------------------------------------------
  20
  21 // if we want to handle threads and Python threads are available...
  22 #if defined(WXP_USE_THREAD) && defined(WITH_THREAD)
  23
  24 #define WXP_WITH_THREAD
  25 #define wxPy_BEGIN_ALLOW_THREADS  Py_BEGIN_ALLOW_THREADS
  26 #define wxPy_END_ALLOW_THREADS    Py_END_ALLOW_THREADS
  27
  28 #else  // no Python threads...
  29 #undef WXP_WITH_THREAD
  30 #define wxPy_BEGIN_ALLOW_THREADS
  31 #define wxPy_END_ALLOW_THREADS
  32 #endif
  33
  34
  35 //---------------------------------------------------------------------------
  36
  37 #if defined(__WXMSW__)
  38 #       define HELPEREXPORT __declspec(dllexport)
  39 #else
  40 #       define HELPEREXPORT
  41 #endif
  42
  43 //----------------------------------------------------------------------
  44
  45 class wxPyApp: public wxApp
  46 {
  47 public:
  48     wxPyApp();
  49     ~wxPyApp();
  50     int  MainLoop(void);
  51     bool OnInit(void);
  52 //#    void AfterMainLoop(void);
  53 };
  54
  55 extern wxPyApp *wxPythonApp;
  56
  57 //----------------------------------------------------------------------
  58
  59 void      __wxPreStart();
  60 PyObject* __wxStart(PyObject*, PyObject* args);
  61
  62 extern PyObject* wxPython_dict;
  63 PyObject* __wxSetDictionary(PyObject*, PyObject* args);
  64
  65 void wxPyEventThunker(wxObject*, wxEvent& event);
  66
  67 HELPEREXPORT PyObject* wxPyConstructObject(void* ptr, char* className);
  68 HELPEREXPORT bool wxPyRestoreThread();
  69 HELPEREXPORT void wxPySaveThread(bool doSave);
  70 HELPEREXPORT PyObject* wxPy_ConvertList(wxListBase* list, char* className);
  71
  72 //----------------------------------------------------------------------
  73
  74
  75 #ifndef SWIGCODE
  76 extern "C" void SWIG_MakePtr(char *, void *, char *);
  77 extern "C" char *SWIG_GetPtr(char *, void **, char *);
  78 extern "C" char *SWIG_GetPtrObj(PyObject *obj, void **ptr, char *type);
  79 #endif
  80
  81
  82 #ifdef _MSC_VER
  83 # pragma warning(disable:4800)
  84 #endif
  85
  86 typedef unsigned char byte;
  87
  88
  89 // Non-const versions to keep SWIG happy.
  90 extern wxPoint  wxPyDefaultPosition;
  91 extern wxSize   wxPyDefaultSize;
  92 extern wxString wxPyEmptyStr;
  93
  94 //----------------------------------------------------------------------
  95
  96 class wxPyCallback : public wxObject {
  97 public:
  98     wxPyCallback(PyObject* func);
  99     ~wxPyCallback();
 100
 101     void EventThunker(wxEvent& event);
 102
 103     PyObject*   m_func;
 104 };
 105
 106 //---------------------------------------------------------------------------
 107
 108 //  class wxPyMenu : public wxMenu {
 109 //  public:
 110 //      wxPyMenu(const wxString& title = "", PyObject* func=NULL);
 111 //      ~wxPyMenu();
 112
 113 //  private:
 114 //      static void MenuCallback(wxMenu& menu, wxCommandEvent& evt);
 115 //      PyObject*   func;
 116 //  };
 117
 118
 119 //---------------------------------------------------------------------------
 120
 121 class wxPyTimer : public wxTimer {
 122 public:
 123     wxPyTimer(PyObject* callback);
 124     ~wxPyTimer();
 125
 126     void        Notify();
 127
 128 private:
 129     PyObject*   func;
 130 };
 131
 132 //---------------------------------------------------------------------------
 133
 134 class wxPyEvent : public wxCommandEvent {
 135     DECLARE_DYNAMIC_CLASS(wxPyEvent)
 136 public:
 137     wxPyEvent(wxEventType commandType = wxEVT_NULL, PyObject* userData = Py_None);
 138     ~wxPyEvent();
 139
 140     void SetUserData(PyObject* userData);
 141     PyObject* GetUserData();
 142
 143 private:
 144     PyObject* m_userData;
 145 };
 146
 147
 148
 149
 150
 151 //---------------------------------------------------------------------------
 152 // This class holds an instance of a Python Shadow Class object and assists
 153 // with looking up and invoking Python callback methods from C++ virtual
 154 // method redirections.  For all classes which have virtuals which should be
 155 // overridable in wxPython, a new subclass is created that contains a
 156 // wxPyCallbackHelper.
 157 //
 158 // **** This class should be combined with wxPyCallback defined above.
 159 //
 160 //---------------------------------------------------------------------------
 161
 162 class HELPEREXPORT wxPyCallbackHelper {
 163 public:
 164     wxPyCallbackHelper();
 165     ~wxPyCallbackHelper();
 166
 167     void        setSelf(PyObject* self);
 168
 169     bool        findCallback(const wxString& name);
 170     int         callCallback(PyObject* argTuple);
 171     PyObject*   callCallbackObj(PyObject* argTuple);
 172
 173 private:
 174     PyObject*   m_self;
 175     PyObject*   m_lastFound;
 176 };
 177
 178
 179
 180 //---------------------------------------------------------------------------
 181 // These macros are used to implement the virtual methods that should
 182 // redirect to a Python method if one exists.  The names designate the
 183 // return type, if any as well as any parameter types.
 184 //---------------------------------------------------------------------------
 185
 186 #define PYPRIVATE                               \
 187     void _setSelf(PyObject* self) {             \
 188         m_myInst.setSelf(self);                 \
 189     }                                           \
 190     private: wxPyCallbackHelper m_myInst;
 191
 192 //---------------------------------------------------------------------------
 193
 194 #define DEC_PYCALLBACK__(CBNAME)                        \
 195     void CBNAME();                                      \
 196     void base_##CBNAME();
 197
 198
 199 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME)         \
 200     void CLASS::CBNAME() {                              \
 201         bool doSave = wxPyRestoreThread();              \
 202         if (m_myInst.findCallback(#CBNAME))             \
 203             m_myInst.callCallback(Py_BuildValue("()")); \
 204         else                                            \
 205             PCLASS::CBNAME();                           \
 206         wxPySaveThread(doSave);                         \
 207     }                                                   \
 208     void CLASS::base_##CBNAME() {                       \
 209         PCLASS::CBNAME();                               \
 210     }
 211
 212 //---------------------------------------------------------------------------
 213
 214 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME)                      \
 215     bool CBNAME(int a, int b);                                  \
 216     bool base_##CBNAME(int a, int b);
 217
 218
 219 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME)               \
 220     bool CLASS::CBNAME(int a, int b) {                                  \
 221         bool rval;                                                      \
 222         bool doSave = wxPyRestoreThread();                              \
 223         if (m_myInst.findCallback(#CBNAME))                             \
 224             rval = m_myInst.callCallback(Py_BuildValue("(ii)",a,b));    \
 225         else                                                            \
 226             rval = PCLASS::CBNAME(a,b);                                 \
 227         wxPySaveThread(doSave);                                         \
 228         return rval;                                                    \
 229     }                                                                   \
 230     bool CLASS::base_##CBNAME(int a, int b) {                           \
 231         return PCLASS::CBNAME(a,b);                                     \
 232     }
 233
 234 //---------------------------------------------------------------------------
 235
 236 #define DEC_PYCALLBACK_BOOL_INT(CBNAME)                         \
 237     bool CBNAME(int a);                                         \
 238     bool base_##CBNAME(int a);
 239
 240
 241 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME)                  \
 242     bool CLASS::CBNAME(int a) {                                         \
 243         bool rval;                                                      \
 244         bool doSave = wxPyRestoreThread();                              \
 245         if (m_myInst.findCallback(#CBNAME))                             \
 246             rval = m_myInst.callCallback(Py_BuildValue("(i)",a));       \
 247         else                                                            \
 248             rval = PCLASS::CBNAME(a);                                   \
 249         wxPySaveThread(doSave);                                         \
 250         return rval;                                                    \
 251     }                                                                   \
 252     bool CLASS::base_##CBNAME(int a) {                                  \
 253         return PCLASS::CBNAME(a);                                       \
 254     }
 255
 256 //---------------------------------------------------------------------------
 257
 258 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME)            \
 259     bool CBNAME(int a);
 260
 261
 262 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME)             \
 263     bool CLASS::CBNAME(int a) {                                         \
 264         bool rval;                                                      \
 265         bool doSave = wxPyRestoreThread();                              \
 266         if (m_myInst.findCallback(#CBNAME))                             \
 267             rval = m_myInst.callCallback(Py_BuildValue("(i)",a));       \
 268         else rval = false;                                              \
 269         wxPySaveThread(doSave);                                         \
 270         return rval;                                                    \
 271     }
 272
 273
 274 //---------------------------------------------------------------------------
 275
 276 #define DEC_PYCALLBACK__DC(CBNAME)                      \
 277     void CBNAME(wxDC& a);                               \
 278     void base_##CBNAME(wxDC& a);
 279
 280
 281 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME)               \
 282     void CLASS::CBNAME(wxDC& a) {                               \
 283         bool doSave = wxPyRestoreThread();                      \
 284         if (m_myInst.findCallback(#CBNAME))                     \
 285             m_myInst.callCallback(Py_BuildValue("(O)",          \
 286                             wxPyConstructObject(&a, "wxDC")));  \
 287         else                                                    \
 288             PCLASS::CBNAME(a);                                  \
 289         wxPySaveThread(doSave);                                 \
 290     }                                                           \
 291     void CLASS::base_##CBNAME(wxDC& a) {                        \
 292         PCLASS::CBNAME(a);                                      \
 293     }
 294
 295
 296
 297 //---------------------------------------------------------------------------
 298
 299 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 300     void CBNAME(wxDC& a, bool b);                       \
 301     void base_##CBNAME(wxDC& a, bool b);
 302
 303
 304 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 305     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 306         bool doSave = wxPyRestoreThread();                              \
 307         if (m_myInst.findCallback(#CBNAME))                             \
 308             m_myInst.callCallback(Py_BuildValue("(Oi)",                 \
 309                             wxPyConstructObject(&a, "wxDC"), (int)b));  \
 310         else                                                            \
 311             PCLASS::CBNAME(a, b);                                       \
 312         wxPySaveThread(doSave);                                         \
 313     }                                                                   \
 314     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 315         PCLASS::CBNAME(a, b);                                           \
 316     }
 317
 318 //---------------------------------------------------------------------------
 319
 320 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                          \
 321     void CBNAME(wxDC& a, bool b);                               \
 322     void base_##CBNAME(wxDC& a, bool b);
 323
 324
 325 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 326     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 327         bool doSave = wxPyRestoreThread();                              \
 328         if (m_myInst.findCallback(#CBNAME))                             \
 329             m_myInst.callCallback(Py_BuildValue("(Oi)",                 \
 330                             wxPyConstructObject(&a, "wxDC"), (int)b));  \
 331         else                                                            \
 332             PCLASS::CBNAME(a, b);                                       \
 333                 wxPySaveThread(doSave);                                 \
 334     }                                                                   \
 335     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 336         PCLASS::CBNAME(a, b);                                           \
 337     }
 338
 339 //---------------------------------------------------------------------------
 340
 341 #define DEC_PYCALLBACK__2DBL(CBNAME)                    \
 342     void CBNAME(double a, double b);                    \
 343     void base_##CBNAME(double a, double b);
 344
 345
 346 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME)             \
 347     void CLASS::CBNAME(double a, double b) {                    \
 348         bool doSave = wxPyRestoreThread();                      \
 349         if (m_myInst.findCallback(#CBNAME))                     \
 350             m_myInst.callCallback(Py_BuildValue("(dd)",a,b));   \
 351         else                                                    \
 352             PCLASS::CBNAME(a, b);                               \
 353         wxPySaveThread(doSave);                                 \
 354     }                                                           \
 355     void CLASS::base_##CBNAME(double a, double b) {             \
 356         PCLASS::CBNAME(a, b);                                   \
 357     }
 358
 359 //---------------------------------------------------------------------------
 360
 361 #define DEC_PYCALLBACK__2DBL2INT(CBNAME)                        \
 362     void CBNAME(double a, double b, int c, int d);              \
 363     void base_##CBNAME(double a, double b, int c, int d);
 364
 365
 366 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 367     void CLASS::CBNAME(double a, double b, int c, int d) {              \
 368         bool doSave = wxPyRestoreThread();                              \
 369         if (m_myInst.findCallback(#CBNAME))                             \
 370             m_myInst.callCallback(Py_BuildValue("(ddii)",               \
 371                                                        a,b,c,d));       \
 372         else                                                            \
 373             PCLASS::CBNAME(a, b, c, d);                                 \
 374         wxPySaveThread(doSave);                                         \
 375     }                                                                   \
 376     void CLASS::base_##CBNAME(double a, double b, int c, int d) {       \
 377         PCLASS::CBNAME(a, b, c, d);                                     \
 378     }
 379
 380 //---------------------------------------------------------------------------
 381
 382 #define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME)                              \
 383     void CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 384     void base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 385
 386
 387 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME)                               \
 388     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 389         bool doSave = wxPyRestoreThread();                                              \
 390         if (m_myInst.findCallback(#CBNAME))                                             \
 391             m_myInst.callCallback(Py_BuildValue("(Oddddi)",                             \
 392                                    wxPyConstructObject(&a, "wxDC"),                     \
 393                                               b, c, d, e, (int)f));                     \
 394         else                                                                            \
 395             PCLASS::CBNAME(a, b, c, d, e, f);                                           \
 396         wxPySaveThread(doSave);                                                         \
 397     }                                                                                   \
 398     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 399         PCLASS::CBNAME(a, b, c, d, e, f);                                               \
 400     }
 401
 402 //---------------------------------------------------------------------------
 403
 404 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME)                                  \
 405     bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f);       \
 406     bool base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f);
 407
 408
 409 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME)                           \
 410     bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {       \
 411         bool doSave = wxPyRestoreThread();                                              \
 412         if (m_myInst.findCallback(#CBNAME))                                             \
 413             return m_myInst.callCallback(Py_BuildValue("(Oddddi)",                      \
 414                                    wxPyConstructObject(&a, "wxDC"),                     \
 415                                               b, c, d, e, (int)f));                     \
 416         else                                                                            \
 417             return PCLASS::CBNAME(a, b, c, d, e, f);                                    \
 418         wxPySaveThread(doSave);                                                         \
 419     }                                                                                   \
 420     bool CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
 421         return PCLASS::CBNAME(a, b, c, d, e, f);                                        \
 422     }
 423
 424 //---------------------------------------------------------------------------
 425
 426 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME)                            \
 427     void CBNAME(bool a, double b, double c, int d, int e);              \
 428     void base_##CBNAME(bool a, double b, double c, int d, int e);
 429
 430
 431 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 432     void CLASS::CBNAME(bool a, double b, double c, int d, int e) {              \
 433         bool doSave = wxPyRestoreThread();                                      \
 434         if (m_myInst.findCallback(#CBNAME))                                     \
 435             m_myInst.callCallback(Py_BuildValue("(idii)",                       \
 436                                                 (int)a,b,c,d,e));               \
 437         else                                                                    \
 438             PCLASS::CBNAME(a, b, c, d, e);                                      \
 439         wxPySaveThread(doSave);                                                 \
 440     }                                                                           \
 441     void CLASS::base_##CBNAME(bool a, double b, double c, int d, int e) {       \
 442         PCLASS::CBNAME(a, b, c, d, e);                                          \
 443     }
 444
 445 //---------------------------------------------------------------------------
 446
 447 #define DEC_PYCALLBACK__DC4DBL(CBNAME)                                      \
 448     void CBNAME(wxDC& a, double b, double c, double d, double e);               \
 449     void base_##CBNAME(wxDC& a, double b, double c, double d, double e);
 450
 451
 452 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME)                           \
 453     void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) {       \
 454         bool doSave = wxPyRestoreThread();                                      \
 455         if (m_myInst.findCallback(#CBNAME))                                     \
 456             m_myInst.callCallback(Py_BuildValue("(Odddd)",                      \
 457                                    wxPyConstructObject(&a, "wxDC"),             \
 458                                                      b, c, d, e));              \
 459         else                                                                    \
 460             PCLASS::CBNAME(a, b, c, d, e);                                      \
 461         wxPySaveThread(doSave);                                                 \
 462     }                                                                           \
 463     void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e) {\
 464         PCLASS::CBNAME(a, b, c, d, e);                                          \
 465     }
 466
 467 //---------------------------------------------------------------------------
 468
 469 #define DEC_PYCALLBACK__DCBOOL(CBNAME)                  \
 470     void CBNAME(wxDC& a, bool b);                       \
 471     void base_##CBNAME(wxDC& a, bool b);
 472
 473
 474 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME)                   \
 475     void CLASS::CBNAME(wxDC& a, bool b) {                               \
 476         bool doSave = wxPyRestoreThread();                              \
 477         if (m_myInst.findCallback(#CBNAME))                             \
 478             m_myInst.callCallback(Py_BuildValue("(Oi)",                 \
 479                                    wxPyConstructObject(&a, "wxDC"),     \
 480                                                      (int)b));          \
 481         else                                                            \
 482             PCLASS::CBNAME(a, b);                                       \
 483         wxPySaveThread(doSave);                                         \
 484     }                                                                   \
 485     void CLASS::base_##CBNAME(wxDC& a, bool b) {                        \
 486         PCLASS::CBNAME(a, b);                                           \
 487     }
 488
 489 //---------------------------------------------------------------------------
 490
 491 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME)                                \
 492     void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);   \
 493     void base_##CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f);
 494
 495
 496 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME)                 \
 497     void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d,           \
 498                 int e, int f) {                                                 \
 499         bool doSave = wxPyRestoreThread();                                      \
 500         if (m_myInst.findCallback(#CBNAME))                                     \
 501             m_myInst.callCallback(Py_BuildValue("(Oiddii)",                     \
 502                                  wxPyConstructObject(a, "wxControlPoint"),      \
 503                                  (int)b, c, d, e, f));                          \
 504         else                                                                    \
 505             PCLASS::CBNAME(a, b, c, d, e, f);                                   \
 506         wxPySaveThread(doSave);                                                 \
 507     }                                                                           \
 508     void CLASS::base_##CBNAME(wxControlPoint* a, bool b, double c, double d,    \
 509                        int e, int f) {                                          \
 510         PCLASS::CBNAME(a, b, c, d, e, f);                                       \
 511     }
 512
 513 //---------------------------------------------------------------------------
 514
 515 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME)                                    \
 516     void CBNAME(wxControlPoint* a, double b, double c, int d, int e);           \
 517     void base_##CBNAME(wxControlPoint* a, double b, double c, int d, int e);
 518
 519
 520 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME)                     \
 521     void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) {   \
 522         bool doSave = wxPyRestoreThread();                                      \
 523         if (m_myInst.findCallback(#CBNAME))                                     \
 524             m_myInst.callCallback(Py_BuildValue("(Oddii)",                      \
 525                                  wxPyConstructObject(a, "wxControlPoint"),      \
 526                                  b, c, d, e));                                  \
 527         else                                                                    \
 528             PCLASS::CBNAME(a, b, c, d, e);                                      \
 529         wxPySaveThread(doSave);                                                 \
 530     }                                                                           \
 531     void CLASS::base_##CBNAME(wxControlPoint* a, double b, double c,            \
 532                        int d, int e) {                                          \
 533         PCLASS::CBNAME(a, b, c, d, e);                                          \
 534     }
 535
 536 //---------------------------------------------------------------------------
 537
 538 #define DEC_PYCALLBACK__2DBLINT(CBNAME)                 \
 539     void CBNAME(double a, double b, int c);             \
 540     void base_##CBNAME(double a, double b, int c);
 541
 542
 543 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME)                  \
 544     void CLASS::CBNAME(double a, double b, int c) {                     \
 545         bool doSave = wxPyRestoreThread();                              \
 546         if (m_myInst.findCallback(#CBNAME))                             \
 547             m_myInst.callCallback(Py_BuildValue("(ddi)", a,b,c));       \
 548         else                                                            \
 549             PCLASS::CBNAME(a, b, c);                                    \
 550         wxPySaveThread(doSave);                                         \
 551     }                                                                   \
 552     void CLASS::base_##CBNAME(double a, double b, int c) {              \
 553         PCLASS::CBNAME(a, b, c);                                        \
 554     }
 555
 556 //---------------------------------------------------------------------------
 557
 558 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME)                     \
 559     void CBNAME(bool a, double b, double c, int d);             \
 560     void base_##CBNAME(bool a, double b, double c, int d);
 561
 562
 563 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME)                      \
 564     void CLASS::CBNAME(bool a, double b, double c, int d) {                     \
 565         bool doSave = wxPyRestoreThread();                                      \
 566         if (m_myInst.findCallback(#CBNAME))                                     \
 567             m_myInst.callCallback(Py_BuildValue("(iddi)", (int)a,b,c,d));       \
 568         else                                                                    \
 569             PCLASS::CBNAME(a, b, c, d);                                         \
 570         wxPySaveThread(doSave);                                                 \
 571     }                                                                           \
 572     void CLASS::base_##CBNAME(bool a, double b, double c, int d) {              \
 573         PCLASS::CBNAME(a, b, c, d);                                             \
 574     }
 575
 576 //---------------------------------------------------------------------------
 577 //---------------------------------------------------------------------------
 578
 579 #define DEC_PYCALLBACK__STRING(CBNAME)                  \
 580     void CBNAME(const wxString& a);                     \
 581     void base_##CBNAME(const wxString& a);
 582
 583
 584 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME)                   \
 585     void CLASS::CBNAME(const wxString& a)  {                            \
 586         bool doSave = wxPyRestoreThread();                              \
 587         if (m_myInst.findCallback(#CBNAME))                             \
 588             m_myInst.callCallback(Py_BuildValue("(s)", a.c_str()));     \
 589         else                                                            \
 590             PCLASS::CBNAME(a);                                          \
 591         wxPySaveThread(doSave);                                         \
 592     }                                                                   \
 593     void CLASS::base_##CBNAME(const wxString& a) {                      \
 594         PCLASS::CBNAME(a);                                              \
 595     }
 596
 597 //---------------------------------------------------------------------------
 598
 599 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME)              \
 600     bool CBNAME(const wxString& a);                     \
 601     bool base_##CBNAME(const wxString& a);
 602
 603
 604 #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME)                       \
 605     bool CLASS::CBNAME(const wxString& a)  {                                    \
 606         bool rval;                                                              \
 607         bool doSave = wxPyRestoreThread();                                      \
 608         if (m_myInst.findCallback(#CBNAME))                                     \
 609             rval = m_myInst.callCallback(Py_BuildValue("(s)", a.c_str()));      \
 610         else                                                                    \
 611             rval = PCLASS::CBNAME(a);                                           \
 612         wxPySaveThread(doSave);                                                 \
 613         return rval;                                                            \
 614     }                                                                           \
 615     bool CLASS::base_##CBNAME(const wxString& a) {                              \
 616         return PCLASS::CBNAME(a);                                               \
 617     }
 618
 619 //---------------------------------------------------------------------------
 620
 621 #define DEC_PYCALLBACK_STRING_(CBNAME)                  \
 622     wxString CBNAME();                                  \
 623     wxString base_##CBNAME();
 624
 625
 626 #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME)                           \
 627     wxString CLASS::CBNAME() {                                                  \
 628         wxString rval;                                                          \
 629         bool doSave = wxPyRestoreThread();                                      \
 630         if (m_myInst.findCallback(#CBNAME)) {                                   \
 631             PyObject* ro;                                                       \
 632             ro = m_myInst.callCallbackObj(Py_BuildValue("()"));                 \
 633             rval = PyString_AsString(PyObject_Str(ro));                         \
 634         }                                                                       \
 635         else                                                                    \
 636             rval = PCLASS::CBNAME(a);                                           \
 637         wxPySaveThread(doSave);                                                 \
 638         return rval;                                                            \
 639     }                                                                           \
 640     bool CLASS::base_##CBNAME(const wxString& a) {                              \
 641         return PCLASS::CBNAME(a);                                               \
 642     }
 643
 644 //---------------------------------------------------------------------------
 645
 646 #define DEC_PYCALLBACK_STRING__pure(CBNAME)             \
 647     wxString CBNAME();
 648
 649
 650 #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME)                      \
 651     wxString CLASS::CBNAME() {                                                  \
 652         wxString rval;                                                          \
 653         bool doSave = wxPyRestoreThread();                                      \
 654         if (m_myInst.findCallback(#CBNAME)) {                                   \
 655             PyObject* ro;                                                       \
 656             ro = m_myInst.callCallbackObj(Py_BuildValue("()"));                 \
 657             rval = PyString_AsString(PyObject_Str(ro));                         \
 658         }                                                                       \
 659         wxPySaveThread(doSave);                                                 \
 660         return rval;                                                            \
 661     }
 662
 663 //---------------------------------------------------------------------------
 664
 665 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME)                  \
 666     bool CBNAME(const wxHtmlTag& a);                          \
 667
 668
 669 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME)                     \
 670     bool CLASS::CBNAME(const wxHtmlTag& a)  {                                   \
 671         bool rval = false;                                                      \
 672         bool doSave = wxPyRestoreThread();                                      \
 673         if (m_myInst.findCallback(#CBNAME))                                     \
 674             rval = m_myInst.callCallback(Py_BuildValue("(O)",                   \
 675                                          wxPyConstructObject((void*)&a,"wxHtmlTag"))); \
 676         wxPySaveThread(doSave);                                                 \
 677         return rval;                                                            \
 678     }
 679
 680 //---------------------------------------------------------------------------
 681 //---------------------------------------------------------------------------
 682 //---------------------------------------------------------------------------
 683 //---------------------------------------------------------------------------
 684 //---------------------------------------------------------------------------
 685
 686 #endif
 687
 688
 689