]> git.saurik.com Git - wxWidgets.git/blob - wxPython/include/wx/wxPython/wxPython_int.h
projects / wxWidgets.git / blob
? search:


f4afefcb7f9a1e6250aaaaf7105b4842d4392b2b
[wxWidgets.git] / wxPython / include / wx / wxPython / wxPython_int.h
1 ////////////////////////////////////////////////////////////////////////////
2 // Name: wxPython_int.h (int == internal)
3 // Purpose: Helper functions/classes for the wxPython extension module
4 // This header should only be inclued directly by those source
5 // modules included in the wx._core module. All others should
6 // include wx/wxPython/wxPython.h instead.
7 //
8 // Author: Robin Dunn
9 //
10 // Created: 1-July-1997
11 // RCS-ID: $Id$
12 // Copyright: (c) 1998 by Total Control Software
13 // Licence: wxWindows license
14 /////////////////////////////////////////////////////////////////////////////
15
16 #ifndef __wxp_helpers__
17 #define __wxp_helpers__
18
19 #include <wx/wx.h>
20
21 #include <wx/busyinfo.h>
22 #include <wx/caret.h>
23 #include <wx/choicebk.h>
24 #include <wx/clipbrd.h>
25 #include <wx/colordlg.h>
26 #include <wx/config.h>
27 #include <wx/cshelp.h>
28 #include <wx/dcmirror.h>
29 #include <wx/dcps.h>
30 #include <wx/dirctrl.h>
31 #include <wx/dirdlg.h>
32 #include <wx/dnd.h>
33 #include <wx/docview.h>
34 #include <wx/encconv.h>
35 #include <wx/fdrepdlg.h>
36 #include <wx/fileconf.h>
37 #include <wx/filesys.h>
38 #include <wx/fontdlg.h>
39 #include <wx/fs_inet.h>
40 #include <wx/fs_mem.h>
41 #include <wx/fs_zip.h>
42 #include <wx/gbsizer.h>
43 #include <wx/geometry.h>
44 #include <wx/htmllbox.h>
45 #include <wx/image.h>
46 #include <wx/imaglist.h>
47 #include <wx/intl.h>
48 #include <wx/laywin.h>
49 #include <wx/listbook.h>
50 #include <wx/minifram.h>
51 #include <wx/notebook.h>
52 #include <wx/print.h>
53 #include <wx/printdlg.h>
54 #include <wx/process.h>
55 #include <wx/progdlg.h>
56 #include <wx/sashwin.h>
57 #include <wx/spinbutt.h>
58 #include <wx/spinctrl.h>
59 #include <wx/splash.h>
60 #include <wx/splitter.h>
61 #include <wx/statline.h>
62 #include <wx/stream.h>
63 #include <wx/sysopt.h>
64 #include <wx/taskbar.h>
65 #include <wx/tglbtn.h>
66 #include <wx/tipwin.h>
67 #include <wx/tooltip.h>
68 #include <wx/vlbox.h>
69 #include <wx/vscroll.h>
70 #include <wx/dateevt.h>
71 #include <wx/datectrl.h>
72
73
74
75 #ifdef _MSC_VER
76 # pragma warning(disable:4800)
77 # pragma warning(disable:4190)
78 #endif
79
80 #ifdef __WXMAC__ // avoid a bug in Carbon headers
81 #define scalb scalbn
82 #endif
83
84 //---------------------------------------------------------------------------
85
86 typedef unsigned char byte;
87 typedef wxPoint2DDouble wxPoint2D;
88
89
90 #ifndef wxPyUSE_EXPORTED_API
91
92 void __wxPyPreStart(PyObject*);
93 void __wxPyCleanup();
94 PyObject* __wxPySetDictionary(PyObject*, PyObject* args);
95 PyObject* __wxPyFixStockObjects(PyObject*, PyObject* args);
96
97 void wxSetDefaultPyEncoding(const char* encoding);
98 const char* wxGetDefaultPyEncoding();
99
100
101 void wxPyEventThunker(wxObject*, wxEvent& event);
102
103
104 bool wxPyCheckSwigType(const wxChar* className);
105 PyObject* wxPyConstructObject(void* ptr,
106 const wxChar* className,
107 int setThisOwn=0);
108 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
109 const wxChar* className);
110 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* classname);
111
112
113 PyObject* wx2PyString(const wxString& src);
114 wxString Py2wxString(PyObject* source);
115
116 PyObject* wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHandler=true);
117 PyObject* wxPyMake_wxSizer(wxSizer* source, bool setThisOwn);
118 void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName);
119
120 PyObject* wxPy_ConvertList(wxListBase* list);
121 long wxPyGetWinHandle(wxWindow* win);
122
123 void wxPy_ReinitStockObjects(int pass);
124
125 bool wxPyInstance_Check(PyObject* obj);
126 bool wxPySwigInstance_Check(PyObject* obj);
127
128
129 #endif // wxPyUSE_EXPORTED_API
130 //---------------------------------------------------------------------------
131
132 // if we want to handle threads and Python threads are available...
133 #if defined(WXP_USE_THREAD) && defined(WITH_THREAD)
134 #define WXP_WITH_THREAD
135 #else // no Python threads...
136 #undef WXP_WITH_THREAD
137 #endif
138
139
140 // In Python 2.3 and later there are the PyGILState_* APIs that we can use for
141 // blocking threads when calling back into Python. Using them instead of my
142 // home-grown hacks greatly simplifies wxPyBeginBlockThreads and
143 // wxPyEndBlockThreads.
144
145 #if PY_VERSION_HEX < 0x02030000
146 #define wxPyUSE_GIL_STATE 0
147 typedef bool wxPyBlock_t;
148 #else
149 #define wxPyUSE_GIL_STATE 1
150 typedef PyGILState_STATE wxPyBlock_t;
151 #endif
152
153
154 #ifndef wxPyUSE_EXPORTED_API
155
156 // For Python --> C++
157 PyThreadState* wxPyBeginAllowThreads();
158 void wxPyEndAllowThreads(PyThreadState* state);
159
160 // For C++ --> Python
161 wxPyBlock_t wxPyBeginBlockThreads();
162 void wxPyEndBlockThreads(wxPyBlock_t blocked);
163
164 #endif // wxPyUSE_EXPORTED_API
165
166
167 // A macro that will help to execute simple statments wrapped in
168 // StartBlock/EndBlockThreads calls
169 #define wxPyBLOCK_THREADS(stmt) \
170 { wxPyBlock_t blocked = wxPyBeginBlockThreads(); stmt; wxPyEndBlockThreads(blocked); }
171
172 // Raise the NotImplementedError exception (blocking threads)
173 #define wxPyRaiseNotImplemented() \
174 wxPyBLOCK_THREADS(PyErr_SetNone(PyExc_NotImplementedError))
175
176 // Raise any exception with a string value (blocking threads)
177 #define wxPyErr_SetString(err, str) \
178 wxPyBLOCK_THREADS(PyErr_SetString(err, str))
179
180
181 //---------------------------------------------------------------------------
182 // These are helpers used by the typemaps
183
184 #ifndef wxPyUSE_EXPORTED_API
185
186 wxString* wxString_in_helper(PyObject* source);
187
188 byte* byte_LIST_helper(PyObject* source);
189 int* int_LIST_helper(PyObject* source);
190 long* long_LIST_helper(PyObject* source);
191 char** string_LIST_helper(PyObject* source);
192 wxPoint* wxPoint_LIST_helper(PyObject* source, int* npoints);
193 wxBitmap** wxBitmap_LIST_helper(PyObject* source);
194 wxString* wxString_LIST_helper(PyObject* source);
195 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
196 wxPen** wxPen_LIST_helper(PyObject* source);
197
198 bool wxSize_helper(PyObject* source, wxSize** obj);
199 bool wxPoint_helper(PyObject* source, wxPoint** obj);
200 bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
201 bool wxRect_helper(PyObject* source, wxRect** obj);
202 bool wxColour_helper(PyObject* source, wxColour** obj);
203 bool wxPoint2D_helper(PyObject* source, wxPoint2D** obj);
204
205
206 bool wxPySimple_typecheck(PyObject* source, const wxChar* classname, int seqLen);
207 bool wxColour_typecheck(PyObject* source);
208
209 bool wxPyCheckForApp();
210
211
212 template<class T>
213 bool wxPyTwoIntItem_helper(PyObject* source, T** obj, const wxChar* name)
214 {
215 // If source is an object instance then it may already be the right type
216 if (wxPySwigInstance_Check(source)) {
217 T* ptr;
218 if (! wxPyConvertSwigPtr(source, (void **)&ptr, name))
219 goto error;
220 *obj = ptr;
221 return true;
222 }
223 // otherwise a 2-tuple of integers is expected
224 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
225 PyObject* o1 = PySequence_GetItem(source, 0);
226 PyObject* o2 = PySequence_GetItem(source, 1);
227 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
228 Py_DECREF(o1);
229 Py_DECREF(o2);
230 goto error;
231 }
232 **obj = T(PyInt_AsLong(o1), PyInt_AsLong(o2));
233 Py_DECREF(o1);
234 Py_DECREF(o2);
235 return true;
236 }
237
238 error:
239 wxString msg;
240 msg.Printf(wxT("Expected a 2-tuple of integers or a %s object."), name);
241 PyErr_SetString(PyExc_TypeError, msg.mb_str());
242 return false;
243 }
244
245
246
247 // Other helpful stuff
248 bool wxPy2int_seq_helper(PyObject* source, int* i1, int* i2);
249 bool wxPy4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4);
250
251 PyObject* wxArrayString2PyList_helper(const wxArrayString& arr);
252 PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr);
253
254 #endif // wxPyUSE_EXPORTED_API
255
256 //---------------------------------------------------------------------------
257
258 #if PYTHON_API_VERSION < 1009
259 #define PySequence_Fast_GET_ITEM(o, i) \
260 (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
261 #endif
262
263 #define RETURN_NONE() { Py_INCREF(Py_None); return Py_None; }
264 #define DECLARE_DEF_STRING(name) static const wxString wxPy##name(wx##name)
265 #define DECLARE_DEF_STRING2(name,val) static const wxString wxPy##name(val)
266
267 //---------------------------------------------------------------------------
268
269 #ifndef wxPyUSE_EXPORTED_API
270
271 class wxPyCallback : public wxObject {
272 DECLARE_ABSTRACT_CLASS(wxPyCallback);
273 public:
274 wxPyCallback(PyObject* func);
275 wxPyCallback(const wxPyCallback& other);
276 ~wxPyCallback();
277
278 void EventThunker(wxEvent& event);
279
280 PyObject* m_func;
281 };
282
283 #endif // wxPyUSE_EXPORTED_API
284 //---------------------------------------------------------------------------
285 //---------------------------------------------------------------------------
286 // These Event classes can be derived from in Python and passed through the
287 // event system without loosing anything. They do this by keeping a reference
288 // to themselves and some special case handling in wxPyCallback::EventThunker.
289
290
291
292 class wxPyEvtSelfRef {
293 public:
294 wxPyEvtSelfRef();
295 ~wxPyEvtSelfRef();
296
297 void SetSelf(PyObject* self, bool clone=false);
298 PyObject* GetSelf() const;
299 bool GetCloned() const { return m_cloned; }
300
301 protected:
302 PyObject* m_self;
303 bool m_cloned;
304 };
305
306
307 class wxPyEvent : public wxEvent, public wxPyEvtSelfRef {
308 DECLARE_ABSTRACT_CLASS(wxPyEvent)
309 public:
310 wxPyEvent(int winid=0, wxEventType commandType = wxEVT_NULL);
311 wxPyEvent(const wxPyEvent& evt);
312 ~wxPyEvent();
313
314 virtual wxEvent* Clone() const { return new wxPyEvent(*this); }
315 };
316
317
318 class wxPyCommandEvent : public wxCommandEvent, public wxPyEvtSelfRef {
319 DECLARE_ABSTRACT_CLASS(wxPyCommandEvent)
320 public:
321 wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0);
322 wxPyCommandEvent(const wxPyCommandEvent& evt);
323 ~wxPyCommandEvent();
324
325 virtual wxEvent* Clone() const { return new wxPyCommandEvent(*this); }
326 };
327
328
329
330 //----------------------------------------------------------------------
331 // Forward decalre a few things used in the exported API
332 class wxPyClientData;
333 class wxPyUserData;
334 class wxPyOORClientData;
335 class wxPyCBInputStream;
336
337 void wxPyClientData_dtor(wxPyClientData* self);
338 void wxPyUserData_dtor(wxPyUserData* self);
339 void wxPyOORClientData_dtor(wxPyOORClientData* self);
340 wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block);
341 wxPyCBInputStream* wxPyCBInputStream_copy(wxPyCBInputStream* other);
342
343 //---------------------------------------------------------------------------
344 // Export a C API in a struct. Other modules will be able to load this from
345 // the wx.core module and will then have safe access to these functions, even if
346 // in another shared library.
347
348 class wxPyCallbackHelper;
349
350 struct wxPyCoreAPI {
351
352 bool (*p_wxPyCheckSwigType)(const wxChar* className);
353 PyObject* (*p_wxPyConstructObject)(void* ptr, const wxChar* className, int setThisOwn);
354 bool (*p_wxPyConvertSwigPtr)(PyObject* obj, void **ptr, const wxChar* className);
355 PyObject* (*p_wxPyMakeSwigPtr)(void* ptr, const wxChar* className);
356
357 PyThreadState* (*p_wxPyBeginAllowThreads)();
358 void (*p_wxPyEndAllowThreads)(PyThreadState* state);
359 wxPyBlock_t (*p_wxPyBeginBlockThreads)();
360 void (*p_wxPyEndBlockThreads)(wxPyBlock_t blocked);
361
362 PyObject* (*p_wxPy_ConvertList)(wxListBase* list);
363
364 wxString* (*p_wxString_in_helper)(PyObject* source);
365 wxString (*p_Py2wxString)(PyObject* source);
366 PyObject* (*p_wx2PyString)(const wxString& src);
367
368 byte* (*p_byte_LIST_helper)(PyObject* source);
369 int* (*p_int_LIST_helper)(PyObject* source);
370 long* (*p_long_LIST_helper)(PyObject* source);
371 char** (*p_string_LIST_helper)(PyObject* source);
372 wxPoint* (*p_wxPoint_LIST_helper)(PyObject* source, int* npoints);
373 wxBitmap** (*p_wxBitmap_LIST_helper)(PyObject* source);
374 wxString* (*p_wxString_LIST_helper)(PyObject* source);
375 wxAcceleratorEntry* (*p_wxAcceleratorEntry_LIST_helper)(PyObject* source);
376
377 bool (*p_wxSize_helper)(PyObject* source, wxSize** obj);
378 bool (*p_wxPoint_helper)(PyObject* source, wxPoint** obj);
379 bool (*p_wxRealPoint_helper)(PyObject* source, wxRealPoint** obj);
380 bool (*p_wxRect_helper)(PyObject* source, wxRect** obj);
381 bool (*p_wxColour_helper)(PyObject* source, wxColour** obj);
382 bool (*p_wxPoint2D_helper)(PyObject* source, wxPoint2DDouble** obj);
383
384
385 bool (*p_wxPySimple_typecheck)(PyObject* source, const wxChar* classname, int seqLen);
386 bool (*p_wxColour_typecheck)(PyObject* source);
387
388 void (*p_wxPyCBH_setCallbackInfo)(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
389 bool (*p_wxPyCBH_findCallback)(const wxPyCallbackHelper& cbh, const char* name);
390 int (*p_wxPyCBH_callCallback)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
391 PyObject* (*p_wxPyCBH_callCallbackObj)(const wxPyCallbackHelper& cbh, PyObject* argTuple);
392 void (*p_wxPyCBH_delete)(wxPyCallbackHelper* cbh);
393
394 PyObject* (*p_wxPyMake_wxObject)(wxObject* source, bool setThisOwn, bool checkEvtHandler);
395 PyObject* (*p_wxPyMake_wxSizer)(wxSizer* source, bool setThisOwn);
396 void (*p_wxPyPtrTypeMap_Add)(const char* commonName, const char* ptrName);
397 bool (*p_wxPy2int_seq_helper)(PyObject* source, int* i1, int* i2);
398 bool (*p_wxPy4int_seq_helper)(PyObject* source, int* i1, int* i2, int* i3, int* i4);
399 PyObject* (*p_wxArrayString2PyList_helper)(const wxArrayString& arr);
400 PyObject* (*p_wxArrayInt2PyList_helper)(const wxArrayInt& arr);
401
402 void (*p_wxPyClientData_dtor)(wxPyClientData*);
403 void (*p_wxPyUserData_dtor)(wxPyUserData*);
404 void (*p_wxPyOORClientData_dtor)(wxPyOORClientData*);
405
406 wxPyCBInputStream* (*p_wxPyCBInputStream_create)(PyObject *py, bool block);
407 wxPyCBInputStream* (*p_wxPyCBInputStream_copy)(wxPyCBInputStream* other);
408
409 bool (*p_wxPyInstance_Check)(PyObject* obj);
410 bool (*p_wxPySwigInstance_Check)(PyObject* obj);
411
412 bool (*p_wxPyCheckForApp)();
413
414 };
415
416 #ifdef wxPyUSE_EXPORTED_API
417 // Notice that this is static, not extern. This is by design, each module
418 // needs one, but doesn't have to use it.
419 static wxPyCoreAPI* wxPyCoreAPIPtr = NULL;
420 inline wxPyCoreAPI* wxPyGetCoreAPIPtr();
421 #endif // wxPyUSE_EXPORTED_API
422
423 //---------------------------------------------------------------------------
424
425 // A wxObject that holds a reference to a Python object
426 class wxPyUserData : public wxObject {
427 public:
428 wxPyUserData(PyObject* obj) {
429 m_obj = obj;
430 Py_INCREF(m_obj);
431 }
432
433 ~wxPyUserData() {
434 #ifdef wxPyUSE_EXPORTED_API
435 wxPyGetCoreAPIPtr()->p_wxPyUserData_dtor(this);
436 #else
437 wxPyUserData_dtor(this);
438 #endif
439 }
440 PyObject* m_obj;
441 };
442
443
444 // A wxClientData that holds a refernece to a Python object
445 class wxPyClientData : public wxClientData {
446 public:
447 wxPyClientData(PyObject* obj, bool incref=true) {
448 m_obj = obj;
449 m_incRef = incref;
450 if (incref)
451 Py_INCREF(m_obj);
452 }
453 ~wxPyClientData() {
454
455 #ifdef wxPyUSE_EXPORTED_API
456 wxPyGetCoreAPIPtr()->p_wxPyClientData_dtor(this);
457 #else
458 wxPyClientData_dtor(this);
459 #endif
460 }
461 PyObject* m_obj;
462 bool m_incRef;
463 };
464
465
466 // Just like wxPyClientData, except when this object is destroyed it does some
467 // OOR magic on the Python Object.
468 class wxPyOORClientData : public wxPyClientData {
469 public:
470 wxPyOORClientData(PyObject* obj, bool incref=true)
471 : wxPyClientData(obj, incref) {}
472 ~wxPyOORClientData() {
473
474 #ifdef wxPyUSE_EXPORTED_API
475 wxPyGetCoreAPIPtr()->p_wxPyOORClientData_dtor(this);
476 #else
477 wxPyOORClientData_dtor(this);
478 #endif
479 }
480 };
481
482
483 //---------------------------------------------------------------------------
484 // This class holds an instance of a Python Shadow Class object and assists
485 // with looking up and invoking Python callback methods from C++ virtual
486 // method redirections. For all classes which have virtuals which should be
487 // overridable in wxPython, a new subclass is created that contains a
488 // wxPyCallbackHelper.
489 //
490
491 class wxPyCallbackHelper {
492 public:
493 wxPyCallbackHelper(const wxPyCallbackHelper& other);
494
495 wxPyCallbackHelper() {
496 m_class = NULL;
497 m_self = NULL;
498 m_lastFound = NULL;
499 m_incRef = false;
500 }
501
502 ~wxPyCallbackHelper() {
503 #ifdef wxPyUSE_EXPORTED_API
504 wxPyGetCoreAPIPtr()->p_wxPyCBH_delete(this);
505 #else
506 wxPyCBH_delete(this);
507 #endif
508 }
509
510 void setSelf(PyObject* self, PyObject* klass, int incref=true);
511 bool findCallback(const char* name) const;
512 int callCallback(PyObject* argTuple) const;
513 PyObject* callCallbackObj(PyObject* argTuple) const;
514 PyObject* GetLastFound() const { return m_lastFound; }
515
516 private:
517 PyObject* m_self;
518 PyObject* m_class;
519 PyObject* m_lastFound;
520 int m_incRef;
521
522 friend void wxPyCBH_delete(wxPyCallbackHelper* cbh);
523 };
524
525
526 void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref);
527 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name);
528 int wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple);
529 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple);
530 void wxPyCBH_delete(wxPyCallbackHelper* cbh);
531
532
533
534
535 //---------------------------------------------------------------------------
536
537 // This is used in C++ classes that need to be able to make callback to
538 // "overloaded" python methods
539
540 #define PYPRIVATE \
541 void _setCallbackInfo(PyObject* self, PyObject* _class, int incref=1) { \
542 wxPyCBH_setCallbackInfo(m_myInst, self, _class, incref); \
543 } \
544 private: wxPyCallbackHelper m_myInst
545
546
547 //---------------------------------------------------------------------------
548 // The wxPythonApp class
549
550 enum {
551 wxPYAPP_ASSERT_SUPPRESS = 1,
552 wxPYAPP_ASSERT_EXCEPTION = 2,
553 wxPYAPP_ASSERT_DIALOG = 4,
554 wxPYAPP_ASSERT_LOG = 8
555 };
556
557 class wxPyApp: public wxApp
558 {
559 DECLARE_ABSTRACT_CLASS(wxPyApp);
560
561 public:
562 wxPyApp();
563 ~wxPyApp();
564 bool OnInit();
565 int MainLoop();
566
567 int GetAssertMode() { return m_assertMode; }
568 void SetAssertMode(int mode) { m_assertMode = mode; }
569
570 virtual bool OnInitGui();
571 virtual int OnExit();
572 #ifdef __WXDEBUG__
573 virtual void OnAssert(const wxChar *file,
574 int line,
575 const wxChar *cond,
576 const wxChar *msg);
577 #endif
578 // virtual int FilterEvent(wxEvent& event); // This one too????
579
580 // For catching Apple Events
581 virtual void MacOpenFile(const wxString &fileName);
582 virtual void MacPrintFile(const wxString &fileName);
583 virtual void MacNewFile();
584 virtual void MacReopenApp();
585
586 static bool GetMacSupportPCMenuShortcuts();
587 static long GetMacAboutMenuItemId();
588 static long GetMacPreferencesMenuItemId();
589 static long GetMacExitMenuItemId();
590 static wxString GetMacHelpMenuTitleName();
591
592 static void SetMacSupportPCMenuShortcuts(bool val);
593 static void SetMacAboutMenuItemId(long val);
594 static void SetMacPreferencesMenuItemId(long val);
595 static void SetMacExitMenuItemId(long val);
596 static void SetMacHelpMenuTitleName(const wxString& val);
597
598
599 void _BootstrapApp();
600
601 // implementation only
602 void SetStartupComplete(bool val) { m_startupComplete = val; };
603
604 PYPRIVATE;
605 int m_assertMode;
606 bool m_startupComplete;
607 };
608
609 extern wxPyApp *wxPythonApp;
610
611
612 //----------------------------------------------------------------------
613 // These macros are used to implement the virtual methods that should
614 // redirect to a Python method if one exists. The names designate the
615 // return type, if any, as well as any parameter types.
616 //---------------------------------------------------------------------------
617
618 #define DEC_PYCALLBACK__(CBNAME) \
619 void CBNAME(); \
620 void base_##CBNAME()
621
622
623 #define IMP_PYCALLBACK__(CLASS, PCLASS, CBNAME) \
624 void CLASS::CBNAME() { \
625 bool found; \
626 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
627 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
628 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
629 wxPyEndBlockThreads(blocked); \
630 if (! found) \
631 PCLASS::CBNAME(); \
632 } \
633 void CLASS::base_##CBNAME() { \
634 PCLASS::CBNAME(); \
635 }
636
637 //---------------------------------------------------------------------------
638
639 #define DEC_PYCALLBACK_BOOL_INTINT(CBNAME) \
640 bool CBNAME(int a, int b); \
641 bool base_##CBNAME(int a, int b)
642
643
644 #define IMP_PYCALLBACK_BOOL_INTINT(CLASS, PCLASS, CBNAME) \
645 bool CLASS::CBNAME(int a, int b) { \
646 bool rval=false, found; \
647 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
648 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
649 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
650 wxPyEndBlockThreads(blocked); \
651 if (! found) \
652 rval = PCLASS::CBNAME(a,b); \
653 return rval; \
654 } \
655 bool CLASS::base_##CBNAME(int a, int b) { \
656 return PCLASS::CBNAME(a,b); \
657 }
658
659 //---------------------------------------------------------------------------
660
661 #define DEC_PYCALLBACK_VOID_(CBNAME) \
662 void CBNAME(); \
663 void base_##CBNAME()
664
665
666 #define IMP_PYCALLBACK_VOID_(CLASS, PCLASS, CBNAME) \
667 void CLASS::CBNAME() { \
668 bool found; \
669 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
670 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
671 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
672 wxPyEndBlockThreads(blocked); \
673 if (! found) \
674 PCLASS::CBNAME(); \
675 } \
676 void CLASS::base_##CBNAME() { \
677 PCLASS::CBNAME(); \
678 }
679
680 //---------------------------------------------------------------------------
681
682 #define DEC_PYCALLBACK_VOID_INTINT(CBNAME) \
683 void CBNAME(int a, int b); \
684 void base_##CBNAME(int a, int b)
685
686
687 #define IMP_PYCALLBACK_VOID_INTINT(CLASS, PCLASS, CBNAME) \
688 void CLASS::CBNAME(int a, int b) { \
689 bool found; \
690 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
691 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
692 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
693 wxPyEndBlockThreads(blocked); \
694 if (! found) \
695 PCLASS::CBNAME(a,b); \
696 } \
697 void CLASS::base_##CBNAME(int a, int b) { \
698 PCLASS::CBNAME(a,b); \
699 }
700
701 //---------------------------------------------------------------------------
702
703 #define DEC_PYCALLBACK_VOID_INT(CBNAME) \
704 void CBNAME(int a); \
705 void base_##CBNAME(int a)
706
707
708 #define IMP_PYCALLBACK_VOID_INT(CLASS, PCLASS, CBNAME) \
709 void CLASS::CBNAME(int a) { \
710 bool found; \
711 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
712 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
713 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a)); \
714 wxPyEndBlockThreads(blocked); \
715 if (! found) \
716 PCLASS::CBNAME(a); \
717 } \
718 void CLASS::base_##CBNAME(int a) { \
719 PCLASS::CBNAME(a); \
720 }
721
722 //---------------------------------------------------------------------------
723
724 #define DEC_PYCALLBACK_VOID_INT4(CBNAME) \
725 void CBNAME(int a, int b, int c, int d); \
726 void base_##CBNAME(int a, int b, int c, int d)
727
728
729 #define IMP_PYCALLBACK_VOID_INT4(CLASS, PCLASS, CBNAME) \
730 void CLASS::CBNAME(int a, int b, int c, int d) { \
731 bool found; \
732 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
733 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
734 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiii)",a,b,c,d)); \
735 wxPyEndBlockThreads(blocked); \
736 if (! found) \
737 PCLASS::CBNAME(a,b,c,d); \
738 } \
739 void CLASS::base_##CBNAME(int a, int b, int c, int d) { \
740 PCLASS::CBNAME(a,b,c,d); \
741 }
742
743 //---------------------------------------------------------------------------
744 #define DEC_PYCALLBACK_VOID_INT5(CBNAME) \
745 void CBNAME(int a, int b, int c, int d, int e); \
746 void base_##CBNAME(int a, int b, int c, int d, int e)
747
748
749 #define IMP_PYCALLBACK_VOID_INT5(CLASS, PCLASS, CBNAME) \
750 void CLASS::CBNAME(int a, int b, int c, int d, int e) { \
751 bool found; \
752 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
753 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
754 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiiii)",a,b,c,d,e)); \
755 wxPyEndBlockThreads(blocked); \
756 if (! found) \
757 PCLASS::CBNAME(a,b,c,d,e); \
758 } \
759 void CLASS::base_##CBNAME(int a, int b, int c, int d, int e) { \
760 PCLASS::CBNAME(a,b,c,d,e); \
761 }
762
763 //---------------------------------------------------------------------------
764
765 #define DEC_PYCALLBACK_VOID_INTPINTP_const(CBNAME) \
766 void CBNAME(int* a, int* b) const; \
767 void base_##CBNAME(int* a, int* b) const
768
769
770 #define IMP_PYCALLBACK_VOID_INTPINTP_const(CLASS, PCLASS, CBNAME) \
771 void CLASS::CBNAME(int* a, int* b) const { \
772 const char* errmsg = #CBNAME " should return a 2-tuple of integers."; \
773 bool found; \
774 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
775 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
776 PyObject* ro; \
777 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
778 if (ro) { \
779 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) { \
780 PyObject* o1 = PySequence_GetItem(ro, 0); \
781 PyObject* o2 = PySequence_GetItem(ro, 1); \
782 if (PyNumber_Check(o1) && PyNumber_Check(o2)) { \
783 *a = PyInt_AsLong(o1); *b = PyInt_AsLong(o2); \
784 } \
785 else \
786 PyErr_SetString(PyExc_TypeError, errmsg); \
787 Py_DECREF(o1); \
788 Py_DECREF(o2); \
789 } \
790 else { \
791 PyErr_SetString(PyExc_TypeError, errmsg); \
792 } \
793 Py_DECREF(ro); \
794 } \
795 } \
796 wxPyEndBlockThreads(blocked); \
797 if (! found) \
798 PCLASS::CBNAME(a,b); \
799 } \
800 void CLASS::base_##CBNAME(int* a, int* b) const { \
801 PCLASS::CBNAME(a,b); \
802 }
803
804
805 //---------------------------------------------------------------------------
806
807 #define DEC_PYCALLBACK_SIZE_const(CBNAME) \
808 wxSize CBNAME() const; \
809 wxSize base_##CBNAME() const
810
811
812 #define IMP_PYCALLBACK_SIZE_const(CLASS, PCLASS, CBNAME) \
813 wxSize CLASS::CBNAME() const { \
814 const char* errmsg = #CBNAME " should return a 2-tuple of integers."; \
815 bool found; wxSize rval(0,0); \
816 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
817 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
818 PyObject* ro; \
819 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
820 if (ro) { \
821 if (PySequence_Check(ro) && PyObject_Length(ro) == 2) { \
822 PyObject* o1 = PySequence_GetItem(ro, 0); \
823 PyObject* o2 = PySequence_GetItem(ro, 1); \
824 if (PyNumber_Check(o1) && PyNumber_Check(o2)) { \
825 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2)); \
826 } \
827 else \
828 PyErr_SetString(PyExc_TypeError, errmsg); \
829 Py_DECREF(o1); \
830 Py_DECREF(o2); \
831 } \
832 else { \
833 PyErr_SetString(PyExc_TypeError, errmsg); \
834 } \
835 Py_DECREF(ro); \
836 } \
837 } \
838 wxPyEndBlockThreads(blocked); \
839 if (! found) \
840 return PCLASS::CBNAME(); \
841 else \
842 return rval; \
843 } \
844 wxSize CLASS::base_##CBNAME() const { \
845 return PCLASS::CBNAME(); \
846 }
847
848
849 //---------------------------------------------------------------------------
850
851 #define DEC_PYCALLBACK_BOOL_BOOL(CBNAME) \
852 bool CBNAME(bool a); \
853 bool base_##CBNAME(bool a)
854
855
856 #define IMP_PYCALLBACK_BOOL_BOOL(CLASS, PCLASS, CBNAME) \
857 bool CLASS::CBNAME(bool a) { \
858 bool rval=false, found; \
859 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
860 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
861 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
862 wxPyEndBlockThreads(blocked); \
863 if (! found) \
864 rval = PCLASS::CBNAME(a); \
865 return rval; \
866 } \
867 bool CLASS::base_##CBNAME(bool a) { \
868 return PCLASS::CBNAME(a); \
869 }
870
871 //---------------------------------------------------------------------------
872
873 #define DEC_PYCALLBACK_BOOL_INT(CBNAME) \
874 bool CBNAME(int a); \
875 bool base_##CBNAME(int a)
876
877
878 #define IMP_PYCALLBACK_BOOL_INT(CLASS, PCLASS, CBNAME) \
879 bool CLASS::CBNAME(int a) { \
880 bool rval=false, found; \
881 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
882 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
883 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a));\
884 wxPyEndBlockThreads(blocked); \
885 if (! found) \
886 rval = PCLASS::CBNAME(a); \
887 return rval; \
888 } \
889 bool CLASS::base_##CBNAME(int a) { \
890 return PCLASS::CBNAME(a); \
891 }
892
893 //---------------------------------------------------------------------------
894
895 #define DEC_PYCALLBACK_BOOL_INT_pure(CBNAME) \
896 bool CBNAME(int a)
897
898
899 #define IMP_PYCALLBACK_BOOL_INT_pure(CLASS, PCLASS, CBNAME) \
900 bool CLASS::CBNAME(int a) { \
901 bool rval=false; \
902 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
903 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
904 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)",a)); \
905 else rval = false; \
906 wxPyEndBlockThreads(blocked); \
907 return rval; \
908 }
909
910
911 //---------------------------------------------------------------------------
912
913 #define DEC_PYCALLBACK__DC(CBNAME) \
914 void CBNAME(wxDC& a); \
915 void base_##CBNAME(wxDC& a)
916
917
918 #define IMP_PYCALLBACK__DC(CLASS, PCLASS, CBNAME) \
919 void CLASS::CBNAME(wxDC& a) { \
920 bool found; \
921 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
922 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
923 PyObject* obj = wxPyMake_wxObject(&a,false); \
924 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
925 Py_DECREF(obj); \
926 } \
927 wxPyEndBlockThreads(blocked); \
928 if (! found) \
929 PCLASS::CBNAME(a); \
930 } \
931 void CLASS::base_##CBNAME(wxDC& a) { \
932 PCLASS::CBNAME(a); \
933 }
934
935
936
937 //---------------------------------------------------------------------------
938
939 #define DEC_PYCALLBACK__DCBOOL(CBNAME) \
940 void CBNAME(wxDC& a, bool b); \
941 void base_##CBNAME(wxDC& a, bool b)
942
943
944 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME) \
945 void CLASS::CBNAME(wxDC& a, bool b) { \
946 bool found; \
947 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
948 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
949 PyObject* obj = wxPyMake_wxObject(&a,false); \
950 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b)); \
951 Py_DECREF(obj); \
952 } \
953 wxPyEndBlockThreads(blocked); \
954 if (! found) \
955 PCLASS::CBNAME(a, b); \
956 } \
957 void CLASS::base_##CBNAME(wxDC& a, bool b) { \
958 PCLASS::CBNAME(a, b); \
959 }
960
961 //---------------------------------------------------------------------------
962
963 #define DEC_PYCALLBACK__DCBOOL(CBNAME) \
964 void CBNAME(wxDC& a, bool b); \
965 void base_##CBNAME(wxDC& a, bool b)
966
967
968 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME) \
969 void CLASS::CBNAME(wxDC& a, bool b) { \
970 bool found; \
971 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
972 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
973 PyObject* obj = wxPyMake_wxObject(&a,false); \
974 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b)); \
975 Py_DECREF(obj); \
976 } \
977 wxPyEndBlockThreads(blocked); \
978 if (! found) \
979 PCLASS::CBNAME(a, b); \
980 } \
981 void CLASS::base_##CBNAME(wxDC& a, bool b) { \
982 PCLASS::CBNAME(a, b); \
983 }
984
985 //---------------------------------------------------------------------------
986
987 #define DEC_PYCALLBACK__2DBL(CBNAME) \
988 void CBNAME(double a, double b); \
989 void base_##CBNAME(double a, double b)
990
991
992 #define IMP_PYCALLBACK__2DBL(CLASS, PCLASS, CBNAME) \
993 void CLASS::CBNAME(double a, double b) { \
994 bool found; \
995 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
996 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
997 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(dd)",a,b)); \
998 wxPyEndBlockThreads(blocked); \
999 if (! found) \
1000 PCLASS::CBNAME(a, b); \
1001 } \
1002 void CLASS::base_##CBNAME(double a, double b) { \
1003 PCLASS::CBNAME(a, b); \
1004 }
1005
1006 //---------------------------------------------------------------------------
1007
1008 #define DEC_PYCALLBACK__2DBL2INT(CBNAME) \
1009 void CBNAME(double a, double b, int c, int d); \
1010 void base_##CBNAME(double a, double b, int c, int d)
1011
1012
1013 #define IMP_PYCALLBACK__2DBL2INT(CLASS, PCLASS, CBNAME) \
1014 void CLASS::CBNAME(double a, double b, int c, int d) { \
1015 bool found; \
1016 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1017 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1018 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddii)", \
1019 a,b,c,d)); \
1020 wxPyEndBlockThreads(blocked); \
1021 if (! found) \
1022 PCLASS::CBNAME(a, b, c, d); \
1023 } \
1024 void CLASS::base_##CBNAME(double a, double b, int c, int d) { \
1025 PCLASS::CBNAME(a, b, c, d); \
1026 }
1027
1028 //---------------------------------------------------------------------------
1029
1030 #define DEC_PYCALLBACK__DC4DBLBOOL(CBNAME) \
1031 void CBNAME(wxDC& a, double b, double c, double d, double e, bool f); \
1032 void base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f)
1033
1034
1035 #define IMP_PYCALLBACK__DC4DBLBOOL(CLASS, PCLASS, CBNAME) \
1036 void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) { \
1037 bool found; \
1038 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1039 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1040 PyObject* obj = wxPyMake_wxObject(&a,false); \
1041 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f)); \
1042 Py_DECREF(obj); \
1043 } \
1044 wxPyEndBlockThreads(blocked); \
1045 if (! found) \
1046 PCLASS::CBNAME(a, b, c, d, e, f); \
1047 } \
1048 void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
1049 PCLASS::CBNAME(a, b, c, d, e, f); \
1050 }
1051
1052 //---------------------------------------------------------------------------
1053
1054 #define DEC_PYCALLBACK_BOOL_DC4DBLBOOL(CBNAME) \
1055 bool CBNAME(wxDC& a, double b, double c, double d, double e, bool f); \
1056 bool base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f)
1057
1058
1059 #define IMP_PYCALLBACK_BOOL_DC4DBLBOOL(CLASS, PCLASS, CBNAME) \
1060 bool CLASS::CBNAME(wxDC& a, double b, double c, double d, double e, bool f) { \
1061 bool found; \
1062 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1063 bool rval=false; \
1064 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1065 PyObject* obj = wxPyMake_wxObject(&a,false); \
1066 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddddi)", obj, b, c, d, e, (int)f));\
1067 Py_DECREF(obj); \
1068 } \
1069 wxPyEndBlockThreads(blocked); \
1070 if (! found) \
1071 rval = PCLASS::CBNAME(a, b, c, d, e, f); \
1072 return rval; \
1073 } \
1074 bool CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e, bool f) {\
1075 return PCLASS::CBNAME(a, b, c, d, e, f); \
1076 }
1077
1078 //---------------------------------------------------------------------------
1079
1080 #define DEC_PYCALLBACK__BOOL2DBL2INT(CBNAME) \
1081 void CBNAME(bool a, double b, double c, int d, int e); \
1082 void base_##CBNAME(bool a, double b, double c, int d, int e)
1083
1084
1085 #define IMP_PYCALLBACK__BOOL2DBL2INT(CLASS, PCLASS, CBNAME) \
1086 void CLASS::CBNAME(bool a, double b, double c, int d, int e) { \
1087 bool found; \
1088 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1089 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1090 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddii)", \
1091 (int)a,b,c,d,e)); \
1092 wxPyEndBlockThreads(blocked); \
1093 if (! found) \
1094 PCLASS::CBNAME(a, b, c, d, e); \
1095 } \
1096 void CLASS::base_##CBNAME(bool a, double b, double c, int d, int e) { \
1097 PCLASS::CBNAME(a, b, c, d, e); \
1098 }
1099
1100 //---------------------------------------------------------------------------
1101
1102 #define DEC_PYCALLBACK__DC4DBL(CBNAME) \
1103 void CBNAME(wxDC& a, double b, double c, double d, double e); \
1104 void base_##CBNAME(wxDC& a, double b, double c, double d, double e)
1105
1106
1107 #define IMP_PYCALLBACK__DC4DBL(CLASS, PCLASS, CBNAME) \
1108 void CLASS::CBNAME(wxDC& a, double b, double c, double d, double e) { \
1109 bool found; \
1110 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1111 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1112 PyObject* obj = wxPyMake_wxObject(&a,false); \
1113 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Odddd)", obj, b, c, d, e)); \
1114 Py_DECREF(obj); \
1115 } \
1116 wxPyEndBlockThreads(blocked); \
1117 if (! found) \
1118 PCLASS::CBNAME(a, b, c, d, e); \
1119 } \
1120 void CLASS::base_##CBNAME(wxDC& a, double b, double c, double d, double e) {\
1121 PCLASS::CBNAME(a, b, c, d, e); \
1122 }
1123
1124 //---------------------------------------------------------------------------
1125
1126 #define DEC_PYCALLBACK__DCBOOL(CBNAME) \
1127 void CBNAME(wxDC& a, bool b); \
1128 void base_##CBNAME(wxDC& a, bool b)
1129
1130
1131 #define IMP_PYCALLBACK__DCBOOL(CLASS, PCLASS, CBNAME) \
1132 void CLASS::CBNAME(wxDC& a, bool b) { \
1133 bool found; \
1134 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1135 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1136 PyObject* obj = wxPyMake_wxObject(&a,false); \
1137 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, (int)b)); \
1138 Py_DECREF(obj); \
1139 } \
1140 wxPyEndBlockThreads(blocked); \
1141 if (! found) \
1142 PCLASS::CBNAME(a, b); \
1143 } \
1144 void CLASS::base_##CBNAME(wxDC& a, bool b) { \
1145 PCLASS::CBNAME(a, b); \
1146 }
1147
1148 //---------------------------------------------------------------------------
1149
1150 #define DEC_PYCALLBACK__WXCPBOOL2DBL2INT(CBNAME) \
1151 void CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f); \
1152 void base_##CBNAME(wxControlPoint* a, bool b, double c, double d, int e, int f)
1153
1154
1155 #define IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PCLASS, CBNAME) \
1156 void CLASS::CBNAME(wxControlPoint* a, bool b, double c, double d, \
1157 int e, int f) { \
1158 bool found; \
1159 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1160 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1161 PyObject* obj = wxPyMake_wxObject(a,false); \
1162 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oiddii)", obj, (int)b, c, d, e, f));\
1163 Py_DECREF(obj); \
1164 } \
1165 wxPyEndBlockThreads(blocked); \
1166 if (! found) \
1167 PCLASS::CBNAME(a, b, c, d, e, f); \
1168 } \
1169 void CLASS::base_##CBNAME(wxControlPoint* a, bool b, double c, double d, \
1170 int e, int f) { \
1171 PCLASS::CBNAME(a, b, c, d, e, f); \
1172 }
1173
1174 //---------------------------------------------------------------------------
1175
1176 #define DEC_PYCALLBACK__WXCP2DBL2INT(CBNAME) \
1177 void CBNAME(wxControlPoint* a, double b, double c, int d, int e); \
1178 void base_##CBNAME(wxControlPoint* a, double b, double c, int d, int e)
1179
1180
1181 #define IMP_PYCALLBACK__WXCP2DBL2INT(CLASS, PCLASS, CBNAME) \
1182 void CLASS::CBNAME(wxControlPoint* a, double b, double c, int d, int e) { \
1183 bool found; \
1184 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1185 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1186 PyObject* obj = wxPyMake_wxObject(a,false); \
1187 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oddii)", obj, b, c, d, e)); \
1188 Py_DECREF(obj); \
1189 } \
1190 wxPyEndBlockThreads(blocked); \
1191 if (! found) \
1192 PCLASS::CBNAME(a, b, c, d, e); \
1193 } \
1194 void CLASS::base_##CBNAME(wxControlPoint* a, double b, double c, \
1195 int d, int e) { \
1196 PCLASS::CBNAME(a, b, c, d, e); \
1197 }
1198
1199 //---------------------------------------------------------------------------
1200
1201 #define DEC_PYCALLBACK__2DBLINT(CBNAME) \
1202 void CBNAME(double a, double b, int c); \
1203 void base_##CBNAME(double a, double b, int c)
1204
1205
1206 #define IMP_PYCALLBACK__2DBLINT(CLASS, PCLASS, CBNAME) \
1207 void CLASS::CBNAME(double a, double b, int c) { \
1208 bool found; \
1209 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1210 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1211 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ddi)", a,b,c)); \
1212 wxPyEndBlockThreads(blocked); \
1213 if (! found) \
1214 PCLASS::CBNAME(a, b, c); \
1215 } \
1216 void CLASS::base_##CBNAME(double a, double b, int c) { \
1217 PCLASS::CBNAME(a, b, c); \
1218 }
1219
1220 //---------------------------------------------------------------------------
1221
1222 #define DEC_PYCALLBACK__BOOL2DBLINT(CBNAME) \
1223 void CBNAME(bool a, double b, double c, int d); \
1224 void base_##CBNAME(bool a, double b, double c, int d)
1225
1226
1227 #define IMP_PYCALLBACK__BOOL2DBLINT(CLASS, PCLASS, CBNAME) \
1228 void CLASS::CBNAME(bool a, double b, double c, int d) { \
1229 bool found; \
1230 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1231 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1232 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iddi)", (int)a,b,c,d));\
1233 wxPyEndBlockThreads(blocked); \
1234 if (! found) \
1235 PCLASS::CBNAME(a, b, c, d); \
1236 } \
1237 void CLASS::base_##CBNAME(bool a, double b, double c, int d) { \
1238 PCLASS::CBNAME(a, b, c, d); \
1239 }
1240
1241 //---------------------------------------------------------------------------
1242 //---------------------------------------------------------------------------
1243
1244 #define DEC_PYCALLBACK__STRING(CBNAME) \
1245 void CBNAME(const wxString& a); \
1246 void base_##CBNAME(const wxString& a)
1247
1248 #define IMP_PYCALLBACK__STRING(CLASS, PCLASS, CBNAME) \
1249 void CLASS::CBNAME(const wxString& a) { \
1250 bool found; \
1251 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1252 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1253 PyObject* s = wx2PyString(a); \
1254 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s)); \
1255 Py_DECREF(s); \
1256 } \
1257 wxPyEndBlockThreads(blocked); \
1258 if (! found) \
1259 PCLASS::CBNAME(a); \
1260 } \
1261 void CLASS::base_##CBNAME(const wxString& a) { \
1262 PCLASS::CBNAME(a); \
1263 }
1264
1265 //---------------------------------------------------------------------------
1266
1267 #define DEC_PYCALLBACK_BOOL_STRING(CBNAME) \
1268 bool CBNAME(const wxString& a); \
1269 bool base_##CBNAME(const wxString& a)
1270
1271 #define IMP_PYCALLBACK_BOOL_STRING(CLASS, PCLASS, CBNAME) \
1272 bool CLASS::CBNAME(const wxString& a) { \
1273 bool rval=false; \
1274 bool found; \
1275 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1276 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1277 PyObject* s = wx2PyString(a); \
1278 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s)); \
1279 Py_DECREF(s); \
1280 } \
1281 wxPyEndBlockThreads(blocked); \
1282 if (! found) \
1283 rval = PCLASS::CBNAME(a); \
1284 return rval; \
1285 } \
1286 bool CLASS::base_##CBNAME(const wxString& a) { \
1287 return PCLASS::CBNAME(a); \
1288 }
1289
1290 //---------------------------------------------------------------------------
1291
1292 #define DEC_PYCALLBACK_BOOL_STRING_pure(CBNAME) \
1293 bool CBNAME(const wxString& a)
1294
1295 #define IMP_PYCALLBACK_BOOL_STRING_pure(CLASS, PCLASS, CBNAME) \
1296 bool CLASS::CBNAME(const wxString& a) { \
1297 bool rval=false; \
1298 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1299 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1300 PyObject* s = wx2PyString(a); \
1301 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s)); \
1302 Py_DECREF(s); \
1303 } \
1304 wxPyEndBlockThreads(blocked); \
1305 return rval; \
1306 } \
1307
1308 //---------------------------------------------------------------------------
1309
1310 #define DEC_PYCALLBACK_STRING_STRING_pure(CBNAME) \
1311 wxString CBNAME(const wxString& a)
1312
1313 #define IMP_PYCALLBACK_STRING_STRING_pure(CLASS, PCLASS, CBNAME) \
1314 wxString CLASS::CBNAME(const wxString& a) { \
1315 wxString rval; \
1316 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1317 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1318 PyObject* ro; \
1319 PyObject* s = wx2PyString(a); \
1320 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", s)); \
1321 Py_DECREF(s); \
1322 if (ro) { \
1323 rval = Py2wxString(ro); \
1324 Py_DECREF(ro); \
1325 } \
1326 } \
1327 wxPyEndBlockThreads(blocked); \
1328 return rval; \
1329 } \
1330
1331 //---------------------------------------------------------------------------
1332
1333 #define DEC_PYCALLBACK_STRING_STRING(CBNAME) \
1334 wxString CBNAME(const wxString& a); \
1335 wxString base_##CBNAME(const wxString& a)
1336
1337 #define IMP_PYCALLBACK_STRING_STRING(CLASS, PCLASS, CBNAME) \
1338 wxString CLASS::CBNAME(const wxString& a) { \
1339 wxString rval; \
1340 bool found; \
1341 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1342 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1343 PyObject* ro; \
1344 PyObject* s = wx2PyString(a); \
1345 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", s)); \
1346 Py_DECREF(s); \
1347 if (ro) { \
1348 rval = Py2wxString(ro); \
1349 Py_DECREF(ro); \
1350 } \
1351 } \
1352 if (! found) \
1353 rval = PCLASS::CBNAME(a); \
1354 wxPyEndBlockThreads(blocked); \
1355 return rval; \
1356 } \
1357
1358 //---------------------------------------------------------------------------
1359
1360 #define DEC_PYCALLBACK_STRING_STRINGINT_pure(CBNAME) \
1361 wxString CBNAME(const wxString& a,int b)
1362
1363 #define IMP_PYCALLBACK_STRING_STRINGINT_pure(CLASS, PCLASS, CBNAME) \
1364 wxString CLASS::CBNAME(const wxString& a,int b) { \
1365 wxString rval; \
1366 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1367 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1368 PyObject* ro; \
1369 PyObject* s = wx2PyString(a); \
1370 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oi)",s,b)); \
1371 Py_DECREF(s); \
1372 if (ro) { \
1373 rval = Py2wxString(ro); \
1374 Py_DECREF(ro); \
1375 } \
1376 } \
1377 wxPyEndBlockThreads(blocked); \
1378 return rval; \
1379 } \
1380
1381 //---------------------------------------------------------------------------
1382
1383 #define DEC_PYCALLBACK_BOOL_STRINGSTRING(CBNAME) \
1384 bool CBNAME(const wxString& a, const wxString& b); \
1385 bool base_##CBNAME(const wxString& a, const wxString& b)
1386
1387 #define IMP_PYCALLBACK_BOOL_STRINGSTRING(CLASS, PCLASS, CBNAME) \
1388 bool CLASS::CBNAME(const wxString& a, const wxString& b) { \
1389 bool rval=false; \
1390 bool found; \
1391 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1392 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1393 PyObject* s1 = wx2PyString(a); \
1394 PyObject* s2 = wx2PyString(b); \
1395 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",s1,s2)); \
1396 Py_DECREF(s1); \
1397 Py_DECREF(s2); \
1398 } \
1399 wxPyEndBlockThreads(blocked); \
1400 if (! found) \
1401 rval = PCLASS::CBNAME(a, b); \
1402 return rval; \
1403 } \
1404 bool CLASS::base_##CBNAME(const wxString& a, const wxString& b) { \
1405 return PCLASS::CBNAME(a, b); \
1406 }
1407
1408 //---------------------------------------------------------------------------
1409
1410 #define DEC_PYCALLBACK_STRING_(CBNAME) \
1411 wxString CBNAME(); \
1412 wxString base_##CBNAME()
1413
1414 #define IMP_PYCALLBACK_STRING_(CLASS, PCLASS, CBNAME) \
1415 wxString CLASS::CBNAME() { \
1416 wxString rval; \
1417 bool found; \
1418 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1419 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1420 PyObject* ro; \
1421 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
1422 if (ro) { \
1423 rval = Py2wxString(ro); \
1424 Py_DECREF(ro); \
1425 } \
1426 } \
1427 wxPyEndBlockThreads(blocked); \
1428 if (! found) \
1429 rval = PCLASS::CBNAME(); \
1430 return rval; \
1431 } \
1432 wxString CLASS::base_##CBNAME() { \
1433 return PCLASS::CBNAME(); \
1434 }
1435
1436 //---------------------------------------------------------------------------
1437
1438 #define DEC_PYCALLBACK_STRING__const(CBNAME) \
1439 wxString CBNAME() const; \
1440 wxString base_##CBNAME() const;
1441
1442 #define IMP_PYCALLBACK_STRING__const(CLASS, PCLASS, CBNAME) \
1443 wxString CLASS::CBNAME() const { \
1444 wxString rval; \
1445 bool found; \
1446 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1447 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1448 PyObject* ro; \
1449 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
1450 if (ro) { \
1451 rval = Py2wxString(ro); \
1452 Py_DECREF(ro); \
1453 } \
1454 } \
1455 wxPyEndBlockThreads(blocked); \
1456 if (! found) \
1457 rval = PCLASS::CBNAME(); \
1458 return rval; \
1459 } \
1460 wxString CLASS::base_##CBNAME() const { \
1461 return PCLASS::CBNAME(); \
1462 }
1463
1464 //---------------------------------------------------------------------------
1465
1466 #define DEC_PYCALLBACK_STRING__pure(CBNAME) \
1467 wxString CBNAME()
1468
1469 #define IMP_PYCALLBACK_STRING__pure(CLASS, PCLASS, CBNAME) \
1470 wxString CLASS::CBNAME() { \
1471 wxString rval; \
1472 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1473 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1474 PyObject* ro; \
1475 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
1476 if (ro) { \
1477 rval = Py2wxString(ro); \
1478 Py_DECREF(ro); \
1479 } \
1480 } \
1481 wxPyEndBlockThreads(blocked); \
1482 return rval; \
1483 }
1484
1485 //---------------------------------------------------------------------------
1486
1487 #define DEC_PYCALLBACK_STRING__constpure(CBNAME) \
1488 wxString CBNAME() const;
1489
1490 #define IMP_PYCALLBACK_STRING__constpure(CLASS, PCLASS, CBNAME) \
1491 wxString CLASS::CBNAME() const { \
1492 wxString rval; \
1493 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1494 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1495 PyObject* ro; \
1496 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
1497 if (ro) { \
1498 rval = Py2wxString(ro); \
1499 Py_DECREF(ro); \
1500 } \
1501 } \
1502 wxPyEndBlockThreads(blocked); \
1503 return rval; \
1504 }
1505
1506 //---------------------------------------------------------------------------
1507
1508 #define DEC_PYCALLBACK_BOOL_TAG_pure(CBNAME) \
1509 bool CBNAME(const wxHtmlTag& a)
1510
1511
1512 #define IMP_PYCALLBACK_BOOL_TAG_pure(CLASS, PCLASS, CBNAME) \
1513 bool CLASS::CBNAME(const wxHtmlTag& a) { \
1514 bool rval=false; \
1515 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1516 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1517 PyObject* obj = wxPyConstructObject((void*)&a, wxT("wxHtmlTag"), 0);\
1518 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
1519 Py_DECREF(obj); \
1520 } \
1521 wxPyEndBlockThreads(blocked); \
1522 return rval; \
1523 }
1524
1525 //---------------------------------------------------------------------------
1526
1527 #define DEC_PYCALLBACK__CELLINTINT(CBNAME) \
1528 void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y); \
1529 void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y)
1530
1531 #define IMP_PYCALLBACK__CELLINTINT(CLASS, PCLASS, CBNAME) \
1532 void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) { \
1533 bool found; \
1534 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1535 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1536 PyObject* obj = wxPyConstructObject((void*)cell, wxT("wxHtmlCell"), 0); \
1537 wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(Oii)",obj,x,y)); \
1538 Py_DECREF(obj); \
1539 } \
1540 wxPyEndBlockThreads(blocked); \
1541 if (! found) \
1542 PCLASS::CBNAME(cell, x, y); \
1543 } \
1544 void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y) { \
1545 PCLASS::CBNAME(cell, x, y); \
1546 }
1547
1548 //---------------------------------------------------------------------------
1549
1550 #define DEC_PYCALLBACK__COLOUR(CBNAME) \
1551 void CBNAME(const wxColour& c); \
1552 void base_##CBNAME(const wxColour& c)
1553
1554 #define IMP_PYCALLBACK__COLOUR(CLASS, PCLASS, CBNAME) \
1555 void CLASS::CBNAME(const wxColour& c) { \
1556 bool found; \
1557 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1558 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1559 PyObject* obj = wxPyConstructObject((void*)&c, wxT("wxColour"), 0); \
1560 wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj)); \
1561 Py_DECREF(obj); \
1562 } \
1563 wxPyEndBlockThreads(blocked); \
1564 if (! found) \
1565 PCLASS::CBNAME(c); \
1566 } \
1567 void CLASS::base_##CBNAME(const wxColour& c) { \
1568 PCLASS::CBNAME(c); \
1569 }
1570
1571 //---------------------------------------------------------------------------
1572
1573 #define DEC_PYCALLBACK__CELLINTINTME(CBNAME) \
1574 void CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e); \
1575 void base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e)
1576
1577 #define IMP_PYCALLBACK__CELLINTINTME(CLASS, PCLASS, CBNAME) \
1578 void CLASS::CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) { \
1579 bool found; \
1580 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1581 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1582 PyObject* obj = wxPyConstructObject((void*)cell, wxT("wxHtmlCell"), 0); \
1583 PyObject* o2 = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0); \
1584 wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OiiO)",obj,x,y,o2)); \
1585 Py_DECREF(obj); \
1586 Py_DECREF(o2); \
1587 } \
1588 wxPyEndBlockThreads(blocked); \
1589 if (! found) \
1590 PCLASS::CBNAME(cell, x, y, e); \
1591 } \
1592 void CLASS::base_##CBNAME(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& e) {\
1593 PCLASS::CBNAME(cell, x, y, e); \
1594 }
1595
1596
1597
1598 //---------------------------------------------------------------------------
1599
1600 #define DEC_PYCALLBACK___pure(CBNAME) \
1601 void CBNAME()
1602
1603
1604 #define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME) \
1605 void CLASS::CBNAME() { \
1606 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1607 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1608 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1609 wxPyEndBlockThreads(blocked); \
1610 }
1611
1612 //---------------------------------------------------------------------------
1613
1614 #define DEC_PYCALLBACK_wxSize__pure(CBNAME) \
1615 wxSize CBNAME()
1616
1617
1618 #define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME) \
1619 wxSize CLASS::CBNAME() { \
1620 const char* errmsg = #CBNAME " should return a 2-tuple of integers or a wxSize object."; \
1621 wxSize rval(0,0); \
1622 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1623 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1624 PyObject* ro; \
1625 wxSize* ptr; \
1626 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
1627 if (ro) { \
1628 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) \
1629 rval = *ptr; \
1630 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) { \
1631 PyObject* o1 = PySequence_GetItem(ro, 0); \
1632 PyObject* o2 = PySequence_GetItem(ro, 1); \
1633 if (PyNumber_Check(o1) && PyNumber_Check(o2)) \
1634 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2)); \
1635 else \
1636 PyErr_SetString(PyExc_TypeError, errmsg); \
1637 Py_DECREF(o1); \
1638 Py_DECREF(o2); \
1639 } \
1640 else { \
1641 PyErr_SetString(PyExc_TypeError, errmsg); \
1642 } \
1643 Py_DECREF(ro); \
1644 } \
1645 } \
1646 wxPyEndBlockThreads(blocked); \
1647 return rval; \
1648 }
1649
1650 //---------------------------------------------------------------------------
1651
1652 #define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME) \
1653 bool CBNAME(wxWindow* a); \
1654 bool base_##CBNAME(wxWindow* a)
1655
1656
1657 #define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME) \
1658 bool CLASS::CBNAME(wxWindow* a) { \
1659 bool rval=false; \
1660 bool found; \
1661 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1662 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1663 PyObject* obj = wxPyMake_wxObject(a,false); \
1664 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
1665 Py_DECREF(obj); \
1666 } \
1667 wxPyEndBlockThreads(blocked); \
1668 if (! found) \
1669 rval = PCLASS::CBNAME(a); \
1670 return rval; \
1671 } \
1672 bool CLASS::base_##CBNAME(wxWindow* a) { \
1673 return PCLASS::CBNAME(a); \
1674 }
1675
1676 //---------------------------------------------------------------------------
1677
1678 #define DEC_PYCALLBACK_BOOL_WXWINDC(CBNAME) \
1679 bool CBNAME(wxWindow* a, wxDC& b); \
1680 bool base_##CBNAME(wxWindow* a, wxDC& b)
1681
1682
1683 #define IMP_PYCALLBACK_BOOL_WXWINDC(CLASS, PCLASS, CBNAME) \
1684 bool CLASS::CBNAME(wxWindow* a, wxDC& b) { \
1685 bool rval=false; \
1686 bool found; \
1687 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1688 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1689 PyObject* win = wxPyMake_wxObject(a,false); \
1690 PyObject* dc = wxPyMake_wxObject(&b,false); \
1691 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));\
1692 Py_DECREF(win); \
1693 Py_DECREF(dc); \
1694 } \
1695 wxPyEndBlockThreads(blocked); \
1696 if (! found) \
1697 rval = PCLASS::CBNAME(a, b); \
1698 return rval; \
1699 } \
1700 bool CLASS::base_##CBNAME(wxWindow* a, wxDC& b) { \
1701 return PCLASS::CBNAME(a, b); \
1702 }
1703
1704 //---------------------------------------------------------------------------
1705
1706 #define DEC_PYCALLBACK_VOID_WXWINBASE(CBNAME) \
1707 void CBNAME(wxWindowBase* a); \
1708 void base_##CBNAME(wxWindowBase* a)
1709
1710
1711 #define IMP_PYCALLBACK_VOID_WXWINBASE(CLASS, PCLASS, CBNAME) \
1712 void CLASS::CBNAME(wxWindowBase* a) { \
1713 bool found; \
1714 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1715 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1716 PyObject* obj = wxPyMake_wxObject(a,false); \
1717 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
1718 Py_DECREF(obj); \
1719 } \
1720 wxPyEndBlockThreads(blocked); \
1721 if (! found) \
1722 PCLASS::CBNAME(a); \
1723 } \
1724 void CLASS::base_##CBNAME(wxWindowBase* a) { \
1725 PCLASS::CBNAME(a); \
1726 }
1727
1728 //---------------------------------------------------------------------------
1729
1730 #define DEC_PYCALLBACK_BOOL_(CBNAME) \
1731 bool CBNAME(); \
1732 bool base_##CBNAME()
1733
1734
1735 #define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME) \
1736 bool CLASS::CBNAME() { \
1737 bool rval=false; \
1738 bool found; \
1739 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1740 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1741 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1742 wxPyEndBlockThreads(blocked); \
1743 if (! found) \
1744 rval = PCLASS::CBNAME(); \
1745 return rval; \
1746 } \
1747 bool CLASS::base_##CBNAME() { \
1748 return PCLASS::CBNAME(); \
1749 }
1750
1751 //---------------------------------------------------------------------------
1752
1753 #define DEC_PYCALLBACK_BOOL_const(CBNAME) \
1754 bool CBNAME() const; \
1755 bool base_##CBNAME() const
1756
1757
1758 #define IMP_PYCALLBACK_BOOL_const(CLASS, PCLASS, CBNAME) \
1759 bool CLASS::CBNAME() const { \
1760 bool rval=false; \
1761 bool found; \
1762 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1763 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1764 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1765 wxPyEndBlockThreads(blocked); \
1766 if (! found) \
1767 rval = PCLASS::CBNAME(); \
1768 return rval; \
1769 } \
1770 bool CLASS::base_##CBNAME() const { \
1771 return PCLASS::CBNAME(); \
1772 }
1773
1774 //---------------------------------------------------------------------------
1775
1776 #define DEC_PYCALLBACK_DR_2WXCDR(CBNAME) \
1777 wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def); \
1778 wxDragResult base_##CBNAME(wxCoord x, wxCoord y, wxDragResult def)
1779
1780
1781 #define IMP_PYCALLBACK_DR_2WXCDR(CLASS, PCLASS, CBNAME) \
1782 wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) { \
1783 int rval=0; \
1784 bool found; \
1785 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1786 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1787 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1788 wxPyEndBlockThreads(blocked); \
1789 if (! found) \
1790 rval = PCLASS::CBNAME(a, b, c); \
1791 return (wxDragResult)rval; \
1792 } \
1793 wxDragResult CLASS::base_##CBNAME(wxCoord a, wxCoord b, wxDragResult c) { \
1794 return PCLASS::CBNAME(a, b, c); \
1795 }
1796
1797 //---------------------------------------------------------------------------
1798
1799 #define DEC_PYCALLBACK_FSF_FSSTRING_pure(CBNAME) \
1800 wxFSFile* CBNAME(wxFileSystem& fs, const wxString& location)
1801
1802 #define IMP_PYCALLBACK_FSF_FSSTRING_pure(CLASS, PCLASS, CBNAME) \
1803 wxFSFile* CLASS::CBNAME(wxFileSystem& a,const wxString& b) { \
1804 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1805 wxFSFile* rval=0; \
1806 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1807 PyObject* ro; \
1808 PyObject* obj = wxPyMake_wxObject(&a,false); \
1809 PyObject* s = wx2PyString(b); \
1810 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)", \
1811 obj, s)); \
1812 if (ro) { \
1813 wxPyConvertSwigPtr(ro, (void **)&rval, wxT("wxFSFile")); \
1814 Py_DECREF(ro); \
1815 } \
1816 Py_DECREF(obj); \
1817 Py_DECREF(s); \
1818 } \
1819 wxPyEndBlockThreads(blocked); \
1820 return rval; \
1821 };
1822
1823 //---------------------------------------------------------------------------
1824
1825 #define DEC_PYCALLBACK_BOOL_DR(CBNAME) \
1826 bool CBNAME(wxDragResult a); \
1827 bool base_##CBNAME(wxDragResult a)
1828
1829
1830 #define IMP_PYCALLBACK_BOOL_DR(CLASS, PCLASS, CBNAME) \
1831 bool CLASS::CBNAME(wxDragResult a) { \
1832 bool rval=false; \
1833 bool found; \
1834 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1835 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1836 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
1837 wxPyEndBlockThreads(blocked); \
1838 if (! found) \
1839 rval = PCLASS::CBNAME(a); \
1840 return rval; \
1841 } \
1842 bool CLASS::base_##CBNAME(wxDragResult a) { \
1843 return PCLASS::CBNAME(a); \
1844 }
1845
1846 //---------------------------------------------------------------------------
1847
1848 #define DEC_PYCALLBACK_DR_2WXCDR_pure(CBNAME) \
1849 wxDragResult CBNAME(wxCoord x, wxCoord y, wxDragResult def)
1850
1851
1852 #define IMP_PYCALLBACK_DR_2WXCDR_pure(CLASS, PCLASS, CBNAME) \
1853 wxDragResult CLASS::CBNAME(wxCoord a, wxCoord b, wxDragResult c) { \
1854 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1855 int rval=0; \
1856 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
1857 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));\
1858 wxPyEndBlockThreads(blocked); \
1859 return (wxDragResult)rval; \
1860 } \
1861
1862 //---------------------------------------------------------------------------
1863
1864 #define DEC_PYCALLBACK_BOOL_INTINTSTR_pure(CBNAME) \
1865 bool CBNAME(int a, int b, const wxString& c)
1866
1867 #define IMP_PYCALLBACK_BOOL_INTINTSTR_pure(CLASS, PCLASS, CBNAME) \
1868 bool CLASS::CBNAME(int a, int b, const wxString& c) { \
1869 bool rval=false; \
1870 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1871 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
1872 PyObject* s = wx2PyString(c); \
1873 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
1874 Py_DECREF(s); \
1875 } \
1876 wxPyEndBlockThreads(blocked); \
1877 return rval; \
1878 } \
1879
1880 //---------------------------------------------------------------------------
1881
1882 #define DEC_PYCALLBACK_SIZET_(CBNAME) \
1883 size_t CBNAME(); \
1884 size_t base_##CBNAME()
1885
1886
1887 #define IMP_PYCALLBACK_SIZET_(CLASS, PCLASS, CBNAME) \
1888 size_t CLASS::CBNAME() { \
1889 size_t rval=0; \
1890 bool found; \
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1892 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1893 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1894 wxPyEndBlockThreads(blocked); \
1895 if (! found) \
1896 rval = PCLASS::CBNAME(); \
1897 return rval; \
1898 } \
1899 size_t CLASS::base_##CBNAME() { \
1900 return PCLASS::CBNAME(); \
1901 }
1902
1903 //---------------------------------------------------------------------------
1904
1905 #define DEC_PYCALLBACK_SIZET__const(CBNAME) \
1906 size_t CBNAME() const; \
1907 size_t base_##CBNAME() const
1908
1909
1910 #define IMP_PYCALLBACK_SIZET__const(CLASS, PCLASS, CBNAME) \
1911 size_t CLASS::CBNAME() const { \
1912 size_t rval=0; \
1913 bool found; \
1914 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1915 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
1916 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
1917 wxPyEndBlockThreads(blocked); \
1918 if (! found) \
1919 rval = PCLASS::CBNAME(); \
1920 return rval; \
1921 } \
1922 size_t CLASS::base_##CBNAME() const { \
1923 return PCLASS::CBNAME(); \
1924 }
1925
1926 //---------------------------------------------------------------------------
1927
1928 #define DEC_PYCALLBACK_DATAFMT_SIZET(CBNAME) \
1929 wxDataFormat CBNAME(size_t a); \
1930 wxDataFormat base_##CBNAME(size_t a)
1931
1932
1933 #define IMP_PYCALLBACK_DATAFMT_SIZET(CLASS, PCLASS, CBNAME) \
1934 wxDataFormat CLASS::CBNAME(size_t a) { \
1935 wxDataFormat rval=0; \
1936 bool found; \
1937 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1938 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1939 PyObject* ro; \
1940 wxDataFormat* ptr; \
1941 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a)); \
1942 if (ro) { \
1943 if (wxPyCOnvertSwigPtr(ro, (void **)&ptr, wxT("wxDataFormat"))) \
1944 rval = *ptr; \
1945 Py_DECREF(ro); \
1946 } \
1947 } \
1948 wxPyEndBlockThreads(blocked); \
1949 if (! found) \
1950 rval = PCLASS::CBNAME(a); \
1951 return rval; \
1952 } \
1953 wxDataFormat CLASS::base_##CBNAME(size_t a) { \
1954 return PCLASS::CBNAME(a); \
1955 }
1956
1957 //---------------------------------------------------------------------------
1958
1959 #define DEC_PYCALLBACK__constany(CBNAME, Type) \
1960 void CBNAME(const Type& a); \
1961 void base_##CBNAME(const Type& a)
1962
1963
1964 #define IMP_PYCALLBACK__constany(CLASS, PCLASS, CBNAME, Type) \
1965 void CLASS::CBNAME(const Type& a) { \
1966 bool found; \
1967 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1968 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1969 PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0); \
1970 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
1971 Py_DECREF(obj); \
1972 } \
1973 wxPyEndBlockThreads(blocked); \
1974 if (! found) \
1975 PCLASS::CBNAME(a); \
1976 } \
1977 void CLASS::base_##CBNAME(const Type& a) { \
1978 PCLASS::CBNAME(a); \
1979 }
1980
1981
1982 //---------------------------------------------------------------------------
1983
1984 #define DEC_PYCALLBACK__any(CBNAME, Type) \
1985 void CBNAME(Type& a); \
1986 void base_##CBNAME(Type& a)
1987
1988
1989 #define IMP_PYCALLBACK__any(CLASS, PCLASS, CBNAME, Type) \
1990 void CLASS::CBNAME(Type& a) { \
1991 bool found; \
1992 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
1993 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
1994 PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0); \
1995 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
1996 Py_DECREF(obj); \
1997 } \
1998 wxPyEndBlockThreads(blocked); \
1999 if (! found) \
2000 PCLASS::CBNAME(a); \
2001 } \
2002 void CLASS::base_##CBNAME(Type& a) { \
2003 PCLASS::CBNAME(a); \
2004 }
2005
2006 //---------------------------------------------------------------------------
2007
2008 #define DEC_PYCALLBACK_bool_any(CBNAME, Type) \
2009 bool CBNAME(Type& a); \
2010 bool base_##CBNAME(Type& a)
2011
2012
2013 #define IMP_PYCALLBACK_bool_any(CLASS, PCLASS, CBNAME, Type) \
2014 bool CLASS::CBNAME(Type& a) { \
2015 bool rv=false; \
2016 bool found; \
2017 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2018 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2019 PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0); \
2020 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
2021 Py_DECREF(obj); \
2022 } \
2023 wxPyEndBlockThreads(blocked); \
2024 if (! found) \
2025 rv = PCLASS::CBNAME(a); \
2026 return rv; \
2027 } \
2028 bool CLASS::base_##CBNAME(Type& a) { \
2029 return PCLASS::CBNAME(a); \
2030 }
2031
2032 //---------------------------------------------------------------------------
2033
2034 #define DEC_PYCALLBACK_bool_anypure(CBNAME, Type) \
2035 bool CBNAME(Type& a)
2036
2037
2038 #define IMP_PYCALLBACK_bool_anypure(CLASS, PCLASS, CBNAME, Type) \
2039 bool CLASS::CBNAME(Type& a) { \
2040 bool rv=false; \
2041 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2042 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2043 PyObject* obj = wxPyConstructObject((void*)&a, wxT(#Type), 0); \
2044 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
2045 Py_DECREF(obj); \
2046 } \
2047 wxPyEndBlockThreads(blocked); \
2048 return rv; \
2049 } \
2050
2051 //---------------------------------------------------------------------------
2052
2053 #define DEC_PYCALLBACK_STRING_LONGLONG(CBNAME) \
2054 wxString CBNAME(long a, long b) const; \
2055 wxString base_##CBNAME(long a, long b) const
2056
2057 #define IMP_PYCALLBACK_STRING_LONGLONG(CLASS, PCLASS, CBNAME) \
2058 wxString CLASS::CBNAME(long a, long b) const { \
2059 wxString rval; \
2060 bool found; \
2061 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2062 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2063 PyObject* ro; \
2064 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ll)",a,b)); \
2065 if (ro) { \
2066 rval = Py2wxString(ro); \
2067 Py_DECREF(ro); \
2068 } \
2069 } \
2070 wxPyEndBlockThreads(blocked); \
2071 if (! found) \
2072 rval = PCLASS::CBNAME(a,b); \
2073 return rval; \
2074 } \
2075 wxString CLASS::base_##CBNAME(long a, long b) const { \
2076 return PCLASS::CBNAME(a,b); \
2077 }
2078
2079 //---------------------------------------------------------------------------
2080
2081 #define DEC_PYCALLBACK_INT_LONG(CBNAME) \
2082 int CBNAME(long a) const; \
2083 int base_##CBNAME(long a) const
2084
2085
2086 #define IMP_PYCALLBACK_INT_LONG(CLASS, PCLASS, CBNAME) \
2087 int CLASS::CBNAME(long a) const { \
2088 int rval=-1; \
2089 bool found; \
2090 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2091 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2092 PyObject* ro; \
2093 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a)); \
2094 if (ro) { \
2095 rval = PyInt_AsLong(ro); \
2096 Py_DECREF(ro); \
2097 } \
2098 } \
2099 wxPyEndBlockThreads(blocked); \
2100 if (! found) \
2101 rval = PCLASS::CBNAME(a); \
2102 return rval; \
2103 } \
2104 int CLASS::base_##CBNAME(long a) const { \
2105 return PCLASS::CBNAME(a); \
2106 }
2107
2108
2109
2110
2111 #define DEC_PYCALLBACK_INT_LONG_virtual(CBNAME) \
2112 int CBNAME(long a) const;
2113
2114
2115 #define IMP_PYCALLBACK_INT_LONG_virtual(CLASS, PCLASS, CBNAME) \
2116 int CLASS::CBNAME(long a) const { \
2117 int rval=-1; /* this rval is important for OnGetItemImage */ \
2118 bool found; \
2119 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2120 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2121 PyObject* ro; \
2122 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a)); \
2123 if (ro) { \
2124 rval = PyInt_AsLong(ro); \
2125 Py_DECREF(ro); \
2126 } \
2127 } \
2128 wxPyEndBlockThreads(blocked); \
2129 return rval; \
2130 }
2131
2132
2133 //---------------------------------------------------------------------------
2134
2135 #define DEC_PYCALLBACK_LISTATTR_LONG(CBNAME) \
2136 wxListItemAttr* CBNAME(long a) const; \
2137 wxListItemAttr* base_##CBNAME(long a) const
2138
2139
2140 #define IMP_PYCALLBACK_LISTATTR_LONG(CLASS, PCLASS, CBNAME) \
2141 wxListItemAttr *CLASS::CBNAME(long a) const { \
2142 wxListItemAttr *rval = NULL; \
2143 bool found; \
2144 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2145 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2146 PyObject* ro; \
2147 wxListItemAttr* ptr; \
2148 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)", a)); \
2149 if (ro) { \
2150 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxListItemAttr")))\
2151 rval = ptr; \
2152 Py_DECREF(ro); \
2153 } \
2154 } \
2155 wxPyEndBlockThreads(blocked); \
2156 if (! found) \
2157 rval = PCLASS::CBNAME(a); \
2158 return rval; \
2159 } \
2160 wxListItemAttr *CLASS::base_##CBNAME(long a) const { \
2161 return PCLASS::CBNAME(a); \
2162 }
2163
2164 //---------------------------------------------------------------------------
2165
2166 #define DEC_PYCALLBACK_BOOL_ME(CBNAME) \
2167 bool CBNAME(wxMouseEvent& e); \
2168 bool base_##CBNAME(wxMouseEvent& e)
2169
2170 #define IMP_PYCALLBACK_BOOL_ME(CLASS, PCLASS, CBNAME) \
2171 bool CLASS::CBNAME(wxMouseEvent& e) { \
2172 bool rval=false; \
2173 bool found; \
2174 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2175 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2176 PyObject* ro; \
2177 PyObject* obj = wxPyConstructObject((void*)&e, wxT("wxMouseEvent"), 0); \
2178 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)",obj)); \
2179 if (ro) { \
2180 rval = PyInt_AsLong(ro); \
2181 Py_DECREF(ro); \
2182 } \
2183 Py_DECREF(obj); \
2184 } \
2185 wxPyEndBlockThreads(blocked); \
2186 if (! found) \
2187 return PCLASS::CBNAME(e); \
2188 return rval; \
2189 } \
2190 bool CLASS::base_##CBNAME(wxMouseEvent& e) { \
2191 return PCLASS::CBNAME(e); \
2192 }
2193
2194
2195 //---------------------------------------------------------------------------
2196
2197 #define DEC_PYCALLBACK_WIZPG__pure(CBNAME) \
2198 wxWizardPage* CBNAME() const
2199
2200 #define IMP_PYCALLBACK_WIZPG__pure(CLASS, PCLASS, CBNAME) \
2201 wxWizardPage* CLASS::CBNAME() const { \
2202 wxWizardPage* rv = NULL; \
2203 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2204 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2205 PyObject* ro; \
2206 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
2207 if (ro) { \
2208 wxPyConvertSwigPtr(ro, (void **)&rv, wxT("wxWizardPage")); \
2209 Py_DECREF(ro); \
2210 } \
2211 } \
2212 wxPyEndBlockThreads(blocked); \
2213 return rv; \
2214 }
2215
2216 //---------------------------------------------------------------------------
2217
2218 #define DEC_PYCALLBACK_BITMAP__pure(CBNAME) \
2219 wxBitmap CBNAME() const
2220
2221 #define IMP_PYCALLBACK_BITMAP__pure(CLASS, PCLASS, CBNAME) \
2222 wxBitmap CLASS::CBNAME() const { \
2223 wxBitmap rv; \
2224 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2225 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2226 PyObject* ro; \
2227 wxBitmap* ptr; \
2228 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
2229 if (ro) { \
2230 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap"))) \
2231 rv = *ptr; \
2232 Py_DECREF(ro); \
2233 } \
2234 } \
2235 wxPyEndBlockThreads(blocked); \
2236 return rv; \
2237 }
2238
2239 //---------------------------------------------------------------------------
2240
2241 #define DEC_PYCALLBACK_OBJECT__pure(CBNAME) \
2242 wxObject* CBNAME()
2243
2244 #define IMP_PYCALLBACK_OBJECT__pure(CLASS, PCLASS, CBNAME) \
2245 wxObject* CLASS::CBNAME() { \
2246 wxObject* rv = NULL; \
2247 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2248 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2249 PyObject* ro; \
2250 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
2251 if (ro) { \
2252 wxPyConvertSwigPtr(ro, (void **)&rv, wxT("wxObject")); \
2253 Py_DECREF(ro); \
2254 } \
2255 } \
2256 wxPyEndBlockThreads(blocked); \
2257 return rv; \
2258 }
2259
2260 //---------------------------------------------------------------------------
2261
2262 #define DEC_PYCALLBACK_OBJECT_STRING_pure(CBNAME) \
2263 wxObject* CBNAME(const wxString& a)
2264
2265 #define IMP_PYCALLBACK_OBJECT_STRING_pure(CLASS, PCLASS, CBNAME) \
2266 wxObject* CLASS::CBNAME(const wxString& a) { \
2267 wxObject* rv = NULL; \
2268 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2269 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2270 PyObject* so = wx2PyString(a); \
2271 PyObject* ro; \
2272 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", so)); \
2273 if (ro) { \
2274 wxPyConvertSwigPtr(ro, (void **)&rv, wxT("wxObject")); \
2275 Py_DECREF(ro); \
2276 } \
2277 Py_DECREF(so); \
2278 } \
2279 wxPyEndBlockThreads(blocked); \
2280 return rv; \
2281 }
2282
2283 //---------------------------------------------------------------------------
2284
2285 #define DEC_PYCALLBACK_BOOL_NODE_pure(CBNAME) \
2286 bool CBNAME(wxXmlNode* a)
2287
2288
2289 #define IMP_PYCALLBACK_BOOL_NODE_pure(CLASS, PCLASS, CBNAME) \
2290 bool CLASS::CBNAME(wxXmlNode* a) { \
2291 bool rv=false; \
2292 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2293 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2294 PyObject* obj = wxPyConstructObject((void*)a, wxT("wxXmlNode"), 0); \
2295 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj)); \
2296 Py_DECREF(obj); \
2297 } \
2298 wxPyEndBlockThreads(blocked); \
2299 return rv; \
2300 } \
2301
2302 //---------------------------------------------------------------------------
2303
2304 #define DEC_PYCALLBACK_COORD_SIZET_constpure(CBNAME) \
2305 wxCoord CBNAME(size_t a) const
2306
2307
2308 #define IMP_PYCALLBACK_COORD_SIZET_constpure(CLASS, PCLASS, CBNAME) \
2309 wxCoord CLASS::CBNAME(size_t a) const { \
2310 wxCoord rval=0; \
2311 bool found; \
2312 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2313 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2314 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
2315 } \
2316 wxPyEndBlockThreads(blocked); \
2317 return rval; \
2318 } \
2319
2320 //---------------------------------------------------------------------------
2321
2322 #define DEC_PYCALLBACK_VOID_SIZETSIZET_const(CBNAME) \
2323 void CBNAME(size_t a, size_t b) const; \
2324 void base_##CBNAME(size_t a, size_t b) const
2325
2326
2327 #define IMP_PYCALLBACK_VOID_SIZETSIZET_const(CLASS, PCLASS, CBNAME) \
2328 void CLASS::CBNAME(size_t a, size_t b) const { \
2329 bool found; \
2330 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2331 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2332 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2333 wxPyEndBlockThreads(blocked); \
2334 if (! found) \
2335 PCLASS::CBNAME(a,b); \
2336 } \
2337 void CLASS::base_##CBNAME(size_t a, size_t b) const { \
2338 PCLASS::CBNAME(a,b); \
2339 }
2340
2341 //---------------------------------------------------------------------------
2342
2343 #define DEC_PYCALLBACK_COORD_const(CBNAME) \
2344 wxCoord CBNAME() const; \
2345 wxCoord base_##CBNAME() const
2346
2347
2348 #define IMP_PYCALLBACK_COORD_const(CLASS, PCLASS, CBNAME) \
2349 wxCoord CLASS::CBNAME() const { \
2350 wxCoord rval=0; \
2351 bool found; \
2352 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2353 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2354 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2355 wxPyEndBlockThreads(blocked); \
2356 if (! found) \
2357 rval = PCLASS::CBNAME(); \
2358 return rval; \
2359 } \
2360 wxCoord CLASS::base_##CBNAME() const { \
2361 return PCLASS::CBNAME(); \
2362 }
2363
2364 //---------------------------------------------------------------------------
2365
2366 #define DEC_PYCALLBACK__DCRECTSIZET_constpure(CBNAME) \
2367 void CBNAME(wxDC& a, const wxRect& b, size_t c) const;
2368
2369
2370 #define IMP_PYCALLBACK__DCRECTSIZET_constpure(CLASS, PCLASS, CBNAME) \
2371 void CLASS::CBNAME(wxDC& a, const wxRect& b, size_t c) const { \
2372 bool found; \
2373 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2374 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2375 PyObject* obj = wxPyMake_wxObject(&a,false); \
2376 PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0); \
2377 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
2378 Py_DECREF(obj); \
2379 } \
2380 wxPyEndBlockThreads(blocked); \
2381 } \
2382
2383 //---------------------------------------------------------------------------
2384
2385 #define DEC_PYCALLBACK__DCRECTSIZET_const(CBNAME) \
2386 void CBNAME(wxDC& a, const wxRect& b, size_t c) const; \
2387 void base_##CBNAME(wxDC& a, const wxRect& b, size_t c) const
2388
2389
2390 #define IMP_PYCALLBACK__DCRECTSIZET_const(CLASS, PCLASS, CBNAME) \
2391 void CLASS::CBNAME(wxDC& a, const wxRect& b, size_t c) const { \
2392 bool found; \
2393 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2394 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2395 PyObject* obj = wxPyMake_wxObject(&a,false); \
2396 PyObject* ro = wxPyConstructObject((void*)&b, wxT("wxRect"), 0); \
2397 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOi)", obj, ro, (int)c)); \
2398 Py_DECREF(obj); \
2399 } \
2400 wxPyEndBlockThreads(blocked); \
2401 if (! found) \
2402 PCLASS::CBNAME(a,b,c); \
2403 } \
2404 void CLASS::base_##CBNAME(wxDC& a, const wxRect& b, size_t c) const { \
2405 PCLASS::CBNAME(a,b,c); \
2406 }
2407
2408 //---------------------------------------------------------------------------
2409
2410
2411 #define DEC_PYCALLBACK_STRING_SIZET(CBNAME) \
2412 wxString CBNAME(size_t a) const; \
2413 wxString base_##CBNAME(size_t a) const
2414
2415 #define IMP_PYCALLBACK_STRING_SIZET(CLASS, PCLASS, CBNAME) \
2416 wxString CLASS::CBNAME(size_t a) const { \
2417 wxString rval; \
2418 bool found; \
2419 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2420 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2421 PyObject* ro; \
2422 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a)); \
2423 if (ro) { \
2424 rval = Py2wxString(ro); \
2425 Py_DECREF(ro); \
2426 } \
2427 } \
2428 wxPyEndBlockThreads(blocked); \
2429 if (! found) \
2430 rval = PCLASS::CBNAME(a); \
2431 return rval; \
2432 } \
2433 wxString CLASS::base_##CBNAME(size_t a) const { \
2434 return PCLASS::CBNAME(a); \
2435 }
2436
2437 //---------------------------------------------------------------------------
2438
2439 #define DEC_PYCALLBACK_STRING_SIZET_pure(CBNAME) \
2440 wxString CBNAME(size_t a) const
2441
2442 #define IMP_PYCALLBACK_STRING_SIZET_pure(CLASS, PCLASS, CBNAME) \
2443 wxString CLASS::CBNAME(size_t a) const { \
2444 wxString rval; \
2445 bool found; \
2446 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2447 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2448 PyObject* ro; \
2449 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(l)",a)); \
2450 if (ro) { \
2451 rval = Py2wxString(ro); \
2452 Py_DECREF(ro); \
2453 } \
2454 } \
2455 wxPyEndBlockThreads(blocked); \
2456 return rval; \
2457 } \
2458
2459 //---------------------------------------------------------------------------
2460
2461 #define DEC_PYCALLBACK_VIZATTR_(CBNAME) \
2462 wxVisualAttributes CBNAME() const; \
2463 wxVisualAttributes base_##CBNAME()
2464
2465
2466 #define IMP_PYCALLBACK_VIZATTR_(CLASS, PCLASS, CBNAME) \
2467 wxVisualAttributes CLASS::CBNAME() const { \
2468 wxVisualAttributes rval; \
2469 bool found; \
2470 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2471 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2472 PyObject* ro; \
2473 wxVisualAttributes* ptr; \
2474 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()")); \
2475 if (ro) { \
2476 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxVisualAttributes"))) \
2477 rval = *ptr; \
2478 Py_DECREF(ro); \
2479 } \
2480 } \
2481 wxPyEndBlockThreads(blocked); \
2482 if (! found) \
2483 rval = PCLASS::CBNAME(); \
2484 return rval; \
2485 } \
2486 wxVisualAttributes CLASS::base_##CBNAME() { \
2487 return PCLASS::CBNAME(); \
2488 }
2489
2490 //---------------------------------------------------------------------------
2491
2492 #endif
wxWidgets (Impactor)