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