]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/helpers.h
projects / wxWidgets.git / blob
? search:


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