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