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