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