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