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