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