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


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