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