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