]> git.saurik.com Git - wxWidgets.git/blame_incremental - wxPython/src/helpers.cpp
no real changes
[wxWidgets.git] / wxPython / src / helpers.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: helpers.cpp
3// Purpose: Helper functions/classes for the wxPython extension module
4//
5// Author: Robin Dunn
6//
7// Created: 7/1/97
8// RCS-ID: $Id$
9// Copyright: (c) 1998 by Total Control Software
10// Licence: wxWindows license
11/////////////////////////////////////////////////////////////////////////////
12
13#include <stdio.h> // get the correct definition of NULL
14
15#undef DEBUG
16#include <Python.h>
17#include "helpers.h"
18
19#ifdef __WXMSW__
20#include <wx/msw/private.h>
21#include <wx/msw/winundef.h>
22#endif
23
24#ifdef __WXGTK__
25#include <gtk/gtk.h>
26#include <gdk/gdkprivate.h>
27#include <wx/gtk/win_gtk.h>
28#endif
29
30
31
32
33#ifdef __WXMSW__ // If building for win32...
34//----------------------------------------------------------------------
35// This gets run when the DLL is loaded. We just need to save a handle.
36//----------------------------------------------------------------------
37
38BOOL WINAPI DllMain(
39 HINSTANCE hinstDLL, // handle to DLL module
40 DWORD fdwReason, // reason for calling function
41 LPVOID lpvReserved // reserved
42 )
43{
44 wxSetInstance(hinstDLL);
45 return 1;
46}
47#endif
48
49//----------------------------------------------------------------------
50// Class for implementing the wxp main application shell.
51//----------------------------------------------------------------------
52
53wxPyApp *wxPythonApp = NULL; // Global instance of application object
54
55
56wxPyApp::wxPyApp() {
57// printf("**** ctor\n");
58}
59
60wxPyApp::~wxPyApp() {
61// printf("**** dtor\n");
62}
63
64
65// This one isn't acutally called... See __wxStart()
66bool wxPyApp::OnInit(void) {
67 return FALSE;
68}
69
70int wxPyApp::MainLoop(void) {
71 int retval = 0;
72
73 DeletePendingObjects();
74#ifdef __WXGTK__
75 m_initialized = wxTopLevelWindows.GetCount() != 0;
76#endif
77
78 if (Initialized()) {
79 retval = wxApp::MainLoop();
80 wxPythonApp->OnExit();
81 }
82 return retval;
83}
84
85
86//---------------------------------------------------------------------
87//----------------------------------------------------------------------
88
89#ifdef __WXMSW__
90#include "wx/msw/msvcrt.h"
91#endif
92
93
94int WXDLLEXPORT wxEntryStart( int argc, char** argv );
95int WXDLLEXPORT wxEntryInitGui();
96void WXDLLEXPORT wxEntryCleanup();
97
98
99#ifdef WXP_WITH_THREAD
100PyInterpreterState* wxPyInterpreter = NULL;
101#endif
102
103
104// This is where we pick up the first part of the wxEntry functionality...
105// The rest is in __wxStart and __wxCleanup. This function is called when
106// wxcmodule is imported. (Before there is a wxApp object.)
107void __wxPreStart()
108{
109
110#ifdef __WXMSW__
111// wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
112#endif
113
114#ifdef WXP_WITH_THREAD
115 PyEval_InitThreads();
116 wxPyInterpreter = PyThreadState_Get()->interp;
117#endif
118
119 // Bail out if there is already windows created. This means that the
120 // toolkit has already been initialized, as in embedding wxPython in
121 // a C++ wxWindows app.
122 if (wxTopLevelWindows.Number() > 0)
123 return;
124
125
126 int argc = 0;
127 char** argv = NULL;
128 PyObject* sysargv = PySys_GetObject("argv");
129 if (sysargv != NULL) {
130 argc = PyList_Size(sysargv);
131 argv = new char*[argc+1];
132 int x;
133 for(x=0; x<argc; x++)
134 argv[x] = copystring(PyString_AsString(PyList_GetItem(sysargv, x)));
135 argv[argc] = NULL;
136 }
137
138 wxEntryStart(argc, argv);
139 delete [] argv;
140}
141
142
143
144// Start the user application, user App's OnInit method is a parameter here
145PyObject* __wxStart(PyObject* /* self */, PyObject* args)
146{
147 PyObject* onInitFunc = NULL;
148 PyObject* arglist;
149 PyObject* result;
150 long bResult;
151
152 if (!PyArg_ParseTuple(args, "O", &onInitFunc))
153 return NULL;
154
155#if 0 // Try it out without this check, see how it does...
156 if (wxTopLevelWindows.Number() > 0) {
157 PyErr_SetString(PyExc_TypeError, "Only 1 wxApp per process!");
158 return NULL;
159 }
160#endif
161
162 // This is the next part of the wxEntry functionality...
163 int argc = 0;
164 char** argv = NULL;
165 PyObject* sysargv = PySys_GetObject("argv");
166 if (sysargv != NULL) {
167 argc = PyList_Size(sysargv);
168 argv = new char*[argc+1];
169 int x;
170 for(x=0; x<argc; x++)
171 argv[x] = copystring(PyString_AsString(PyList_GetItem(sysargv, x)));
172 argv[argc] = NULL;
173 }
174 wxPythonApp->argc = argc;
175 wxPythonApp->argv = argv;
176
177 wxEntryInitGui();
178
179 // Call the Python App's OnInit function
180 arglist = PyTuple_New(0);
181 result = PyEval_CallObject(onInitFunc, arglist);
182 if (!result) { // an exception was raised.
183 return NULL;
184 }
185
186 if (! PyInt_Check(result)) {
187 PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
188 return NULL;
189 }
190 bResult = PyInt_AS_LONG(result);
191 if (! bResult) {
192 PyErr_SetString(PyExc_SystemExit, "OnInit returned FALSE, exiting...");
193 return NULL;
194 }
195
196#ifdef __WXGTK__
197 wxTheApp->m_initialized = (wxTopLevelWindows.GetCount() > 0);
198#endif
199
200 Py_INCREF(Py_None);
201 return Py_None;
202}
203
204void __wxCleanup() {
205 wxEntryCleanup();
206}
207
208
209
210static PyObject* wxPython_dict = NULL;
211static PyObject* wxPyPtrTypeMap = NULL;
212
213PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
214{
215
216 if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
217 return NULL;
218
219 if (!PyDict_Check(wxPython_dict)) {
220 PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!");
221 return NULL;
222 }
223
224 if (! wxPyPtrTypeMap)
225 wxPyPtrTypeMap = PyDict_New();
226 PyDict_SetItemString(wxPython_dict, "__wxPyPtrTypeMap", wxPyPtrTypeMap);
227
228
229#ifdef __WXMOTIF__
230#define wxPlatform "__WXMOTIF__"
231#endif
232#ifdef __WXQT__
233#define wxPlatform "__WXQT__"
234#endif
235#ifdef __WXGTK__
236#define wxPlatform "__WXGTK__"
237#endif
238#if defined(__WIN32__) || defined(__WXMSW__)
239#define wxPlatform "__WXMSW__"
240#endif
241#ifdef __WXMAC__
242#define wxPlatform "__WXMAC__"
243#endif
244
245 PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
246
247 Py_INCREF(Py_None);
248 return Py_None;
249}
250
251
252//---------------------------------------------------------------------------
253// Stuff used by OOR to find the right wxPython class type to return and to
254// build it.
255
256
257// The pointer type map is used when the "pointer" type name generated by SWIG
258// is not the same as the shadow class name, for example wxPyTreeCtrl
259// vs. wxTreeCtrl. It needs to be referenced in Python as well as from C++,
260// so we'll just make it a Python dictionary in the wx module's namespace.
261void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
262 if (! wxPyPtrTypeMap)
263 wxPyPtrTypeMap = PyDict_New();
264
265 PyDict_SetItemString(wxPyPtrTypeMap,
266 (char*)commonName,
267 PyString_FromString((char*)ptrName));
268}
269
270
271
272PyObject* wxPyClassExists(const char* className) {
273
274 if (!className)
275 return NULL;
276
277 char buff[64]; // should always be big enough...
278
279 sprintf(buff, "%sPtr", className);
280 PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
281
282 return classobj; // returns NULL if not found
283}
284
285
286PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
287 PyObject* target = NULL;
288 bool isEvtHandler = FALSE;
289
290 if (source) {
291 // If it's derived from wxEvtHandler then there may
292 // already be a pointer to a Python object that we can use
293 // in the OOR data.
294 if (checkEvtHandler && wxIsKindOf(source, wxEvtHandler)) {
295 isEvtHandler = TRUE;
296 wxEvtHandler* eh = (wxEvtHandler*)source;
297 wxPyClientData* data = (wxPyClientData*)eh->GetClientObject();
298 if (data) {
299 target = data->m_obj;
300 Py_INCREF(target);
301 }
302 }
303
304 if (! target) {
305 // Otherwise make it the old fashioned way by making a
306 // new shadow object and putting this pointer in it.
307 wxClassInfo* info = source->GetClassInfo();
308 wxChar* name = (wxChar*)info->GetClassName();
309 PyObject* klass = wxPyClassExists(name);
310 while (info && !klass) {
311 name = (wxChar*)info->GetBaseClassName1();
312 info = wxClassInfo::FindClass(name);
313 klass = wxPyClassExists(name);
314 }
315 if (info) {
316 target = wxPyConstructObject(source, name, klass, FALSE);
317 if (target && isEvtHandler)
318 ((wxEvtHandler*)source)->SetClientObject(new wxPyClientData(target));
319 } else {
320 wxString msg("wxPython class not found for ");
321 msg += source->GetClassInfo()->GetClassName();
322 PyErr_SetString(PyExc_NameError, msg.c_str());
323 target = NULL;
324 }
325 }
326 } else { // source was NULL so return None.
327 Py_INCREF(Py_None); target = Py_None;
328 }
329 return target;
330}
331
332
333PyObject* wxPyMake_wxSizer(wxSizer* source) {
334 PyObject* target = NULL;
335
336 if (source && wxIsKindOf(source, wxSizer)) {
337 // If it's derived from wxSizer then there may
338 // already be a pointer to a Python object that we can use
339 // in the OOR data.
340 wxSizer* sz = (wxSizer*)source;
341 wxPyClientData* data = (wxPyClientData*)sz->GetClientObject();
342 if (data) {
343 target = data->m_obj;
344 Py_INCREF(target);
345 }
346 }
347 if (! target) {
348 target = wxPyMake_wxObject(source, FALSE);
349 if (target != Py_None)
350 ((wxSizer*)source)->SetClientObject(new wxPyClientData(target));
351 }
352 return target;
353}
354
355
356
357//---------------------------------------------------------------------------
358
359PyObject* wxPyConstructObject(void* ptr,
360 const char* className,
361 PyObject* klass,
362 int setThisOwn) {
363
364 PyObject* obj;
365 PyObject* arg;
366 PyObject* item;
367 char swigptr[64]; // should always be big enough...
368 char buff[64];
369
370 if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)className)) != NULL) {
371 className = PyString_AsString(item);
372 }
373 sprintf(buff, "_%s_p", className);
374 SWIG_MakePtr(swigptr, ptr, buff);
375
376 arg = Py_BuildValue("(s)", swigptr);
377 obj = PyInstance_New(klass, arg, NULL);
378 Py_DECREF(arg);
379
380 if (setThisOwn) {
381 PyObject* one = PyInt_FromLong(1);
382 PyObject_SetAttrString(obj, "thisown", one);
383 Py_DECREF(one);
384 }
385
386 return obj;
387}
388
389
390PyObject* wxPyConstructObject(void* ptr,
391 const char* className,
392 int setThisOwn) {
393 PyObject* obj;
394
395 if (!ptr) {
396 Py_INCREF(Py_None);
397 return Py_None;
398 }
399
400 char buff[64]; // should always be big enough...
401 sprintf(buff, "%sPtr", className);
402
403 wxASSERT_MSG(wxPython_dict, "wxPython_dict is not set yet!!");
404
405 PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
406 if (! classobj) {
407 char temp[128];
408 sprintf(temp,
409 "*** Unknown class name %s, tell Robin about it please ***",
410 buff);
411 obj = PyString_FromString(temp);
412 return obj;
413 }
414
415 return wxPyConstructObject(ptr, className, classobj, setThisOwn);
416}
417
418//---------------------------------------------------------------------------
419
420
421wxPyTState* wxPyBeginBlockThreads() {
422 wxPyTState* state = NULL;
423#ifdef WXP_WITH_THREAD
424 if (1) { // Can I check if I've already got the lock?
425 state = new wxPyTState;
426 PyEval_AcquireLock();
427 state->newState = PyThreadState_New(wxPyInterpreter);
428 state->prevState = PyThreadState_Swap(state->newState);
429 }
430#endif
431 return state;
432}
433
434
435void wxPyEndBlockThreads(wxPyTState* state) {
436#ifdef WXP_WITH_THREAD
437 if (state) {
438 PyThreadState_Swap(state->prevState);
439 PyThreadState_Clear(state->newState);
440 PyEval_ReleaseLock();
441 PyThreadState_Delete(state->newState);
442 delete state;
443 }
444#endif
445}
446
447
448//---------------------------------------------------------------------------
449
450IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
451
452wxPyCallback::wxPyCallback(PyObject* func) {
453 m_func = func;
454 Py_INCREF(m_func);
455}
456
457wxPyCallback::wxPyCallback(const wxPyCallback& other) {
458 m_func = other.m_func;
459 Py_INCREF(m_func);
460}
461
462wxPyCallback::~wxPyCallback() {
463 wxPyTState* state = wxPyBeginBlockThreads();
464 Py_DECREF(m_func);
465 wxPyEndBlockThreads(state);
466}
467
468
469
470// This function is used for all events destined for Python event handlers.
471void wxPyCallback::EventThunker(wxEvent& event) {
472 wxPyCallback* cb = (wxPyCallback*)event.m_callbackUserData;
473 PyObject* func = cb->m_func;
474 PyObject* result;
475 PyObject* arg;
476 PyObject* tuple;
477
478
479 wxPyTState* state = wxPyBeginBlockThreads();
480 wxString className = event.GetClassInfo()->GetClassName();
481
482 if (className == "wxPyEvent")
483 arg = ((wxPyEvent*)&event)->GetSelf();
484 else if (className == "wxPyCommandEvent")
485 arg = ((wxPyCommandEvent*)&event)->GetSelf();
486 else
487 arg = wxPyConstructObject((void*)&event, className);
488
489 tuple = PyTuple_New(1);
490 PyTuple_SET_ITEM(tuple, 0, arg);
491 result = PyEval_CallObject(func, tuple);
492 Py_DECREF(tuple);
493 if (result) {
494 Py_DECREF(result);
495 PyErr_Clear(); // Just in case...
496 } else {
497 PyErr_Print();
498 }
499 wxPyEndBlockThreads(state);
500}
501
502
503//----------------------------------------------------------------------
504
505wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) {
506 m_lastFound = NULL;
507 m_self = other.m_self;
508 m_class = other.m_class;
509 if (m_self) {
510 Py_INCREF(m_self);
511 Py_INCREF(m_class);
512 }
513}
514
515
516void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* klass, int incref) {
517 m_self = self;
518 m_class = klass;
519 m_incRef = incref;
520 if (incref) {
521 Py_INCREF(m_self);
522 Py_INCREF(m_class);
523 }
524}
525
526
527#if PYTHON_API_VERSION >= 1011
528
529// Prior to Python 2.2 PyMethod_GetClass returned the class object
530// in which the method was defined. Starting with 2.2 it returns
531// "class that asked for the method" which seems totally bogus to me
532// but apprently if fixes some obscure problem waiting to happen in
533// Python. Since the API was not documented Guido and the gang felt
534// safe in changing it. Needless to say that totally screwed up the
535// logic below in wxPyCallbackHelper::findCallback, hence this icky
536// code to find the class where the method is actuallt defined...
537
538static
539PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name)
540{
541 int i, n;
542
543 if (PyType_Check(klass)) { // new style classes
544 // This code is borrowed/adapted from _PyType_Lookup in typeobject.c
545 // (TODO: This part is not tested yet, so I'm not sure it is correct...)
546 PyTypeObject* type = (PyTypeObject*)klass;
547 PyObject *mro, *res, *base, *dict;
548 /* Look in tp_dict of types in MRO */
549 mro = type->tp_mro;
550 assert(PyTuple_Check(mro));
551 n = PyTuple_GET_SIZE(mro);
552 for (i = 0; i < n; i++) {
553 base = PyTuple_GET_ITEM(mro, i);
554 if (PyClass_Check(base))
555 dict = ((PyClassObject *)base)->cl_dict;
556 else {
557 assert(PyType_Check(base));
558 dict = ((PyTypeObject *)base)->tp_dict;
559 }
560 assert(dict && PyDict_Check(dict));
561 res = PyDict_GetItem(dict, name);
562 if (res != NULL)
563 return base;
564 }
565 return NULL;
566 }
567
568 else if (PyClass_Check(klass)) { // old style classes
569 // This code is borrowed/adapted from class_lookup in classobject.c
570 PyClassObject* cp = (PyClassObject*)klass;
571 PyObject *value = PyDict_GetItem(cp->cl_dict, name);
572 if (value != NULL) {
573 return (PyObject*)cp;
574 }
575 n = PyTuple_Size(cp->cl_bases);
576 for (i = 0; i < n; i++) {
577 PyObject* base = PyTuple_GetItem(cp->cl_bases, i);
578 PyObject *v = PyFindClassWithAttr(base, name);
579 if (v != NULL)
580 return v;
581 }
582 return NULL;
583 }
584}
585#endif
586
587
588static
589PyObject* PyMethod_GetDefiningClass(PyObject* method, const char* name)
590{
591 PyObject* mgc = PyMethod_GET_CLASS(method);
592
593#if PYTHON_API_VERSION <= 1010 // prior to Python 2.2, the easy way
594 return mgc;
595#else // 2.2 and after, the hard way...
596
597 PyObject* nameo = PyString_FromString(name);
598 PyObject* klass = PyFindClassWithAttr(mgc, nameo);
599 Py_DECREF(nameo);
600 return klass;
601#endif
602}
603
604
605
606bool wxPyCallbackHelper::findCallback(const char* name) const {
607 wxPyCallbackHelper* self = (wxPyCallbackHelper*)this; // cast away const
608 self->m_lastFound = NULL;
609
610 // If the object (m_self) has an attibute of the given name...
611 if (m_self && PyObject_HasAttrString(m_self, (char*)name)) {
612 PyObject *method, *klass;
613 method = PyObject_GetAttrString(m_self, (char*)name);
614
615 // ...and if that attribute is a method, and if that method's class is
616 // not from a base class...
617 if (PyMethod_Check(method) &&
618 (klass = PyMethod_GetDefiningClass(method, (char*)name)) != NULL &&
619 ((klass == m_class) || PyClass_IsSubclass(klass, m_class))) {
620
621 // ...then we'll save a pointer to the method so callCallback can call it.
622 self->m_lastFound = method;
623 }
624 else {
625 Py_DECREF(method);
626 }
627 }
628 return m_lastFound != NULL;
629}
630
631
632int wxPyCallbackHelper::callCallback(PyObject* argTuple) const {
633 PyObject* result;
634 int retval = FALSE;
635
636 result = callCallbackObj(argTuple);
637 if (result) { // Assumes an integer return type...
638 retval = PyInt_AsLong(result);
639 Py_DECREF(result);
640 PyErr_Clear(); // forget about it if it's not...
641 }
642 return retval;
643}
644
645// Invoke the Python callable object, returning the raw PyObject return
646// value. Caller should DECREF the return value and also call PyEval_SaveThread.
647PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const {
648 PyObject* result;
649
650 // Save a copy of the pointer in case the callback generates another
651 // callback. In that case m_lastFound will have a different value when
652 // it gets back here...
653 PyObject* method = m_lastFound;
654
655 result = PyEval_CallObject(method, argTuple);
656 Py_DECREF(argTuple);
657 Py_DECREF(method);
658 if (!result) {
659 PyErr_Print();
660 }
661 return result;
662}
663
664
665void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref) {
666 cbh.setSelf(self, klass, incref);
667}
668
669bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name) {
670 return cbh.findCallback(name);
671}
672
673int wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple) {
674 return cbh.callCallback(argTuple);
675}
676
677PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple) {
678 return cbh.callCallbackObj(argTuple);
679}
680
681
682void wxPyCBH_delete(wxPyCallbackHelper* cbh) {
683 if (cbh->m_incRef) {
684 wxPyTState* state = wxPyBeginBlockThreads();
685 Py_XDECREF(cbh->m_self);
686 Py_XDECREF(cbh->m_class);
687 wxPyEndBlockThreads(state);
688 }
689}
690
691//---------------------------------------------------------------------------
692//---------------------------------------------------------------------------
693// These event classes can be derived from in Python and passed through the event
694// system without losing anything. They do this by keeping a reference to
695// themselves and some special case handling in wxPyCallback::EventThunker.
696
697
698wxPyEvtSelfRef::wxPyEvtSelfRef() {
699 //m_self = Py_None; // **** We don't do normal ref counting to prevent
700 //Py_INCREF(m_self); // circular loops...
701 m_cloned = FALSE;
702}
703
704wxPyEvtSelfRef::~wxPyEvtSelfRef() {
705 wxPyTState* state = wxPyBeginBlockThreads();
706 if (m_cloned)
707 Py_DECREF(m_self);
708 wxPyEndBlockThreads(state);
709}
710
711void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) {
712 wxPyTState* state = wxPyBeginBlockThreads();
713 if (m_cloned)
714 Py_DECREF(m_self);
715 m_self = self;
716 if (clone) {
717 Py_INCREF(m_self);
718 m_cloned = TRUE;
719 }
720 wxPyEndBlockThreads(state);
721}
722
723PyObject* wxPyEvtSelfRef::GetSelf() const {
724 Py_INCREF(m_self);
725 return m_self;
726}
727
728
729IMPLEMENT_ABSTRACT_CLASS(wxPyEvent, wxEvent);
730IMPLEMENT_ABSTRACT_CLASS(wxPyCommandEvent, wxCommandEvent);
731
732
733wxPyEvent::wxPyEvent(int id)
734 : wxEvent(id) {
735}
736
737
738wxPyEvent::wxPyEvent(const wxPyEvent& evt)
739 : wxEvent(evt)
740{
741 SetSelf(evt.m_self, TRUE);
742}
743
744
745wxPyEvent::~wxPyEvent() {
746}
747
748
749wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id)
750 : wxCommandEvent(commandType, id) {
751}
752
753
754wxPyCommandEvent::wxPyCommandEvent(const wxPyCommandEvent& evt)
755 : wxCommandEvent(evt)
756{
757 SetSelf(evt.m_self, TRUE);
758}
759
760
761wxPyCommandEvent::~wxPyCommandEvent() {
762}
763
764
765
766
767//---------------------------------------------------------------------------
768//---------------------------------------------------------------------------
769
770
771wxPyTimer::wxPyTimer(PyObject* callback) {
772 func = callback;
773 Py_INCREF(func);
774}
775
776wxPyTimer::~wxPyTimer() {
777 wxPyTState* state = wxPyBeginBlockThreads();
778 Py_DECREF(func);
779 wxPyEndBlockThreads(state);
780}
781
782void wxPyTimer::Notify() {
783 if (!func || func == Py_None) {
784 wxTimer::Notify();
785 }
786 else {
787 wxPyTState* state = wxPyBeginBlockThreads();
788
789 PyObject* result;
790 PyObject* args = Py_BuildValue("()");
791
792 result = PyEval_CallObject(func, args);
793 Py_DECREF(args);
794 if (result) {
795 Py_DECREF(result);
796 PyErr_Clear();
797 } else {
798 PyErr_Print();
799 }
800
801 wxPyEndBlockThreads(state);
802 }
803}
804
805
806
807//---------------------------------------------------------------------------
808//---------------------------------------------------------------------------
809// Convert a wxList to a Python List
810
811PyObject* wxPy_ConvertList(wxListBase* list, const char* className) {
812 PyObject* pyList;
813 PyObject* pyObj;
814 wxObject* wxObj;
815 wxNode* node = list->First();
816
817 wxPyTState* state = wxPyBeginBlockThreads();
818 pyList = PyList_New(0);
819 while (node) {
820 wxObj = node->Data();
821 pyObj = wxPyMake_wxObject(wxObj); //wxPyConstructObject(wxObj, className);
822 PyList_Append(pyList, pyObj);
823 node = node->Next();
824 }
825 wxPyEndBlockThreads(state);
826 return pyList;
827}
828
829//----------------------------------------------------------------------
830
831long wxPyGetWinHandle(wxWindow* win) {
832#ifdef __WXMSW__
833 return (long)win->GetHandle();
834#endif
835
836 // Find and return the actual X-Window.
837#ifdef __WXGTK__
838 if (win->m_wxwindow) {
839 GdkWindowPrivate* bwin = (GdkWindowPrivate*)GTK_PIZZA(win->m_wxwindow)->bin_window;
840 if (bwin) {
841 return (long)bwin->xwindow;
842 }
843 }
844#endif
845 return 0;
846}
847
848//----------------------------------------------------------------------
849// Some helper functions for typemaps in my_typemaps.i, so they won't be
850// included in every file...
851
852
853byte* byte_LIST_helper(PyObject* source) {
854 if (!PyList_Check(source)) {
855 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
856 return NULL;
857 }
858 int count = PyList_Size(source);
859 byte* temp = new byte[count];
860 if (! temp) {
861 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
862 return NULL;
863 }
864 for (int x=0; x<count; x++) {
865 PyObject* o = PyList_GetItem(source, x);
866 if (! PyInt_Check(o)) {
867 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
868 return NULL;
869 }
870 temp[x] = (byte)PyInt_AsLong(o);
871 }
872 return temp;
873}
874
875
876int* int_LIST_helper(PyObject* source) {
877 if (!PyList_Check(source)) {
878 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
879 return NULL;
880 }
881 int count = PyList_Size(source);
882 int* temp = new int[count];
883 if (! temp) {
884 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
885 return NULL;
886 }
887 for (int x=0; x<count; x++) {
888 PyObject* o = PyList_GetItem(source, x);
889 if (! PyInt_Check(o)) {
890 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
891 return NULL;
892 }
893 temp[x] = PyInt_AsLong(o);
894 }
895 return temp;
896}
897
898
899long* long_LIST_helper(PyObject* source) {
900 if (!PyList_Check(source)) {
901 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
902 return NULL;
903 }
904 int count = PyList_Size(source);
905 long* temp = new long[count];
906 if (! temp) {
907 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
908 return NULL;
909 }
910 for (int x=0; x<count; x++) {
911 PyObject* o = PyList_GetItem(source, x);
912 if (! PyInt_Check(o)) {
913 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
914 return NULL;
915 }
916 temp[x] = PyInt_AsLong(o);
917 }
918 return temp;
919}
920
921
922char** string_LIST_helper(PyObject* source) {
923 if (!PyList_Check(source)) {
924 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
925 return NULL;
926 }
927 int count = PyList_Size(source);
928 char** temp = new char*[count];
929 if (! temp) {
930 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
931 return NULL;
932 }
933 for (int x=0; x<count; x++) {
934 PyObject* o = PyList_GetItem(source, x);
935 if (! PyString_Check(o)) {
936 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
937 return NULL;
938 }
939 temp[x] = PyString_AsString(o);
940 }
941 return temp;
942}
943
944//--------------------------------
945// Part of patch from Tim Hochberg
946static inline bool wxPointFromObjects(PyObject* o1, PyObject* o2, wxPoint* point) {
947 if (PyInt_Check(o1) && PyInt_Check(o2)) {
948 point->x = PyInt_AS_LONG(o1);
949 point->y = PyInt_AS_LONG(o2);
950 return true;
951 }
952 if (PyFloat_Check(o1) && PyFloat_Check(o2)) {
953 point->x = (int)PyFloat_AS_DOUBLE(o1);
954 point->y = (int)PyFloat_AS_DOUBLE(o2);
955 return true;
956 }
957 if (PyInstance_Check(o1) || PyInstance_Check(o2)) {
958 // Disallow instances because they can cause havok
959 return false;
960 }
961 if (PyNumber_Check(o1) && PyNumber_Check(o2)) {
962 // I believe this excludes instances, so this should be safe without INCREFFing o1 and o2
963 point->x = PyInt_AsLong(o1);
964 point->y = PyInt_AsLong(o2);
965 return true;
966 }
967 return false;
968}
969
970
971wxPoint* wxPoint_LIST_helper(PyObject* source, int *count) {
972 // Putting all of the declarations here allows
973 // us to put the error handling all in one place.
974 int x;
975 wxPoint* temp;
976 PyObject *o, *o1, *o2;
977 bool isFast = PyList_Check(source) || PyTuple_Check(source);
978
979 if (!PySequence_Check(source)) {
980 goto error0;
981 }
982
983 // The length of the sequence is returned in count.
984 *count = PySequence_Length(source);
985 if (*count < 0) {
986 goto error0;
987 }
988
989 temp = new wxPoint[*count];
990 if (!temp) {
991 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
992 return NULL;
993 }
994 for (x=0; x<*count; x++) {
995 // Get an item: try fast way first.
996 if (isFast) {
997 o = PySequence_Fast_GET_ITEM(source, x);
998 }
999 else {
1000 o = PySequence_GetItem(source, x);
1001 if (o == NULL) {
1002 goto error1;
1003 }
1004 }
1005
1006 // Convert o to wxPoint.
1007 if ((PyTuple_Check(o) && PyTuple_GET_SIZE(o) == 2) ||
1008 (PyList_Check(o) && PyList_GET_SIZE(o) == 2)) {
1009 o1 = PySequence_Fast_GET_ITEM(o, 0);
1010 o2 = PySequence_Fast_GET_ITEM(o, 1);
1011 if (!wxPointFromObjects(o1, o2, &temp[x])) {
1012 goto error2;
1013 }
1014 }
1015 else if (PyInstance_Check(o)) {
1016 wxPoint* pt;
1017 if (SWIG_GetPtrObj(o, (void **)&pt, "_wxPoint_p")) {
1018 goto error2;
1019 }
1020 temp[x] = *pt;
1021 }
1022 else if (PySequence_Check(o) && PySequence_Length(o) == 2) {
1023 o1 = PySequence_GetItem(o, 0);
1024 o2 = PySequence_GetItem(o, 1);
1025 if (!wxPointFromObjects(o1, o2, &temp[x])) {
1026 goto error3;
1027 }
1028 Py_DECREF(o1);
1029 Py_DECREF(o2);
1030 }
1031 else {
1032 goto error2;
1033 }
1034 // Clean up.
1035 if (!isFast)
1036 Py_DECREF(o);
1037 }
1038 return temp;
1039
1040error3:
1041 Py_DECREF(o1);
1042 Py_DECREF(o2);
1043error2:
1044 if (!isFast)
1045 Py_DECREF(o);
1046error1:
1047 delete temp;
1048error0:
1049 PyErr_SetString(PyExc_TypeError, "Expected a sequence of length-2 sequences or wxPoints.");
1050 return NULL;
1051}
1052// end of patch
1053//------------------------------
1054
1055
1056wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
1057 if (!PyList_Check(source)) {
1058 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1059 return NULL;
1060 }
1061 int count = PyList_Size(source);
1062 wxBitmap** temp = new wxBitmap*[count];
1063 if (! temp) {
1064 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1065 return NULL;
1066 }
1067 for (int x=0; x<count; x++) {
1068 PyObject* o = PyList_GetItem(source, x);
1069 if (PyInstance_Check(o)) {
1070 wxBitmap* pt;
1071 if (SWIG_GetPtrObj(o, (void **) &pt,"_wxBitmap_p")) {
1072 PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
1073 return NULL;
1074 }
1075 temp[x] = pt;
1076 }
1077 else {
1078 PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
1079 return NULL;
1080 }
1081 }
1082 return temp;
1083}
1084
1085
1086
1087wxString* wxString_LIST_helper(PyObject* source) {
1088 if (!PyList_Check(source)) {
1089 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1090 return NULL;
1091 }
1092 int count = PyList_Size(source);
1093 wxString* temp = new wxString[count];
1094 if (! temp) {
1095 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1096 return NULL;
1097 }
1098 for (int x=0; x<count; x++) {
1099 PyObject* o = PyList_GetItem(source, x);
1100#if PYTHON_API_VERSION >= 1009
1101 if (! PyString_Check(o) && ! PyUnicode_Check(o)) {
1102 PyErr_SetString(PyExc_TypeError, "Expected a list of string or unicode objects.");
1103 return NULL;
1104 }
1105
1106 char* buff;
1107 int length;
1108 if (PyString_AsStringAndSize(o, &buff, &length) == -1)
1109 return NULL;
1110 temp[x] = wxString(buff, length);
1111#else
1112 if (! PyString_Check(o)) {
1113 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1114 return NULL;
1115 }
1116 temp[x] = PyString_AsString(o);
1117#endif
1118 }
1119 return temp;
1120}
1121
1122
1123wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
1124 if (!PyList_Check(source)) {
1125 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1126 return NULL;
1127 }
1128 int count = PyList_Size(source);
1129 wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
1130 if (! temp) {
1131 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1132 return NULL;
1133 }
1134 for (int x=0; x<count; x++) {
1135 PyObject* o = PyList_GetItem(source, x);
1136 if (PyInstance_Check(o)) {
1137 wxAcceleratorEntry* ae;
1138 if (SWIG_GetPtrObj(o, (void **) &ae,"_wxAcceleratorEntry_p")) {
1139 PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
1140 return NULL;
1141 }
1142 temp[x] = *ae;
1143 }
1144 else if (PyTuple_Check(o)) {
1145 PyObject* o1 = PyTuple_GetItem(o, 0);
1146 PyObject* o2 = PyTuple_GetItem(o, 1);
1147 PyObject* o3 = PyTuple_GetItem(o, 2);
1148 temp[x].Set(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3));
1149 }
1150 else {
1151 PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
1152 return NULL;
1153 }
1154 }
1155 return temp;
1156}
1157
1158
1159wxPen** wxPen_LIST_helper(PyObject* source) {
1160 if (!PyList_Check(source)) {
1161 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1162 return NULL;
1163 }
1164 int count = PyList_Size(source);
1165 wxPen** temp = new wxPen*[count];
1166 if (!temp) {
1167 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1168 return NULL;
1169 }
1170 for (int x=0; x<count; x++) {
1171 PyObject* o = PyList_GetItem(source, x);
1172 if (PyInstance_Check(o)) {
1173 wxPen* pt;
1174 if (SWIG_GetPtrObj(o, (void **) &pt,"_wxPen_p")) {
1175 delete temp;
1176 PyErr_SetString(PyExc_TypeError,"Expected _wxPen_p.");
1177 return NULL;
1178 }
1179 temp[x] = pt;
1180 }
1181 else {
1182 delete temp;
1183 PyErr_SetString(PyExc_TypeError, "Expected a list of wxPens.");
1184 return NULL;
1185 }
1186 }
1187 return temp;
1188}
1189
1190
1191bool _2int_seq_helper(PyObject* source, int* i1, int* i2) {
1192 bool isFast = PyList_Check(source) || PyTuple_Check(source);
1193 PyObject *o1, *o2;
1194
1195 if (!PySequence_Check(source) || PySequence_Length(source) != 2)
1196 return FALSE;
1197
1198 if (isFast) {
1199 o1 = PySequence_Fast_GET_ITEM(source, 0);
1200 o2 = PySequence_Fast_GET_ITEM(source, 1);
1201 }
1202 else {
1203 o1 = PySequence_GetItem(source, 0);
1204 o2 = PySequence_GetItem(source, 1);
1205 }
1206
1207 *i1 = PyInt_AsLong(o1);
1208 *i2 = PyInt_AsLong(o2);
1209
1210 if (! isFast) {
1211 Py_DECREF(o1);
1212 Py_DECREF(o2);
1213 }
1214 return TRUE;
1215}
1216
1217
1218bool _4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4) {
1219 bool isFast = PyList_Check(source) || PyTuple_Check(source);
1220 PyObject *o1, *o2, *o3, *o4;
1221
1222 if (!PySequence_Check(source) || PySequence_Length(source) != 4)
1223 return FALSE;
1224
1225 if (isFast) {
1226 o1 = PySequence_Fast_GET_ITEM(source, 0);
1227 o2 = PySequence_Fast_GET_ITEM(source, 1);
1228 o3 = PySequence_Fast_GET_ITEM(source, 2);
1229 o4 = PySequence_Fast_GET_ITEM(source, 3);
1230 }
1231 else {
1232 o1 = PySequence_GetItem(source, 0);
1233 o2 = PySequence_GetItem(source, 1);
1234 o3 = PySequence_GetItem(source, 2);
1235 o4 = PySequence_GetItem(source, 3);
1236 }
1237
1238 *i1 = PyInt_AsLong(o1);
1239 *i2 = PyInt_AsLong(o2);
1240 *i3 = PyInt_AsLong(o3);
1241 *i4 = PyInt_AsLong(o4);
1242
1243 if (! isFast) {
1244 Py_DECREF(o1);
1245 Py_DECREF(o2);
1246 Py_DECREF(o3);
1247 Py_DECREF(o4);
1248 }
1249 return TRUE;
1250}
1251
1252
1253//----------------------------------------------------------------------
1254
1255bool wxSize_helper(PyObject* source, wxSize** obj) {
1256
1257 // If source is an object instance then it may already be the right type
1258 if (PyInstance_Check(source)) {
1259 wxSize* ptr;
1260 if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxSize_p"))
1261 goto error;
1262 *obj = ptr;
1263 return TRUE;
1264 }
1265 // otherwise a 2-tuple of integers is expected
1266 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
1267 PyObject* o1 = PySequence_GetItem(source, 0);
1268 PyObject* o2 = PySequence_GetItem(source, 1);
1269 **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
1270 return TRUE;
1271 }
1272
1273 error:
1274 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxSize object.");
1275 return FALSE;
1276}
1277
1278bool wxPoint_helper(PyObject* source, wxPoint** obj) {
1279
1280 // If source is an object instance then it may already be the right type
1281 if (PyInstance_Check(source)) {
1282 wxPoint* ptr;
1283 if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxPoint_p"))
1284 goto error;
1285 *obj = ptr;
1286 return TRUE;
1287 }
1288 // otherwise a length-2 sequence of integers is expected
1289 if (PySequence_Check(source) && PySequence_Length(source) == 2) {
1290 PyObject* o1 = PySequence_GetItem(source, 0);
1291 PyObject* o2 = PySequence_GetItem(source, 1);
1292 // This should really check for integers, not numbers -- but that would break code.
1293 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
1294 Py_DECREF(o1);
1295 Py_DECREF(o2);
1296 goto error;
1297 }
1298 **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
1299 Py_DECREF(o1);
1300 Py_DECREF(o2);
1301 return TRUE;
1302 }
1303 error:
1304 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxPoint object.");
1305 return FALSE;
1306}
1307
1308
1309
1310bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
1311
1312 // If source is an object instance then it may already be the right type
1313 if (PyInstance_Check(source)) {
1314 wxRealPoint* ptr;
1315 if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRealPoint_p"))
1316 goto error;
1317 *obj = ptr;
1318 return TRUE;
1319 }
1320 // otherwise a 2-tuple of floats is expected
1321 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
1322 PyObject* o1 = PySequence_GetItem(source, 0);
1323 PyObject* o2 = PySequence_GetItem(source, 1);
1324 **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
1325 return TRUE;
1326 }
1327
1328 error:
1329 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object.");
1330 return FALSE;
1331}
1332
1333
1334
1335
1336bool wxRect_helper(PyObject* source, wxRect** obj) {
1337
1338 // If source is an object instance then it may already be the right type
1339 if (PyInstance_Check(source)) {
1340 wxRect* ptr;
1341 if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRect_p"))
1342 goto error;
1343 *obj = ptr;
1344 return TRUE;
1345 }
1346 // otherwise a 4-tuple of integers is expected
1347 else if (PySequence_Check(source) && PyObject_Length(source) == 4) {
1348 PyObject* o1 = PySequence_GetItem(source, 0);
1349 PyObject* o2 = PySequence_GetItem(source, 1);
1350 PyObject* o3 = PySequence_GetItem(source, 2);
1351 PyObject* o4 = PySequence_GetItem(source, 3);
1352 **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),
1353 PyInt_AsLong(o3), PyInt_AsLong(o4));
1354 return TRUE;
1355 }
1356
1357 error:
1358 PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object.");
1359 return FALSE;
1360}
1361
1362
1363
1364bool wxColour_helper(PyObject* source, wxColour** obj) {
1365
1366 // If source is an object instance then it may already be the right type
1367 if (PyInstance_Check(source)) {
1368 wxColour* ptr;
1369 if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxColour_p"))
1370 goto error;
1371 *obj = ptr;
1372 return TRUE;
1373 }
1374 // otherwise a string is expected
1375 else if (PyString_Check(source)) {
1376 wxString spec = PyString_AS_STRING(source);
1377 if (spec[0U] == '#' && spec.Length() == 7) { // It's #RRGGBB
1378 char* junk;
1379 int red = strtol(spec.Mid(1,2), &junk, 16);
1380 int green = strtol(spec.Mid(3,2), &junk, 16);
1381 int blue = strtol(spec.Mid(5,2), &junk, 16);
1382 **obj = wxColour(red, green, blue);
1383 return TRUE;
1384 }
1385 else { // it's a colour name
1386 **obj = wxColour(spec);
1387 return TRUE;
1388 }
1389 }
1390
1391 error:
1392 PyErr_SetString(PyExc_TypeError, "Expected a wxColour object or a string containing a colour name or '#RRGGBB'.");
1393 return FALSE;
1394}
1395
1396
1397//----------------------------------------------------------------------
1398
1399PyObject* wxArrayString2PyList_helper(const wxArrayString& arr) {
1400
1401 PyObject* list = PyList_New(0);
1402 for (size_t i=0; i < arr.GetCount(); i++) {
1403 PyObject* str = PyString_FromString(arr[i].c_str());
1404 PyList_Append(list, str);
1405 Py_DECREF(str);
1406 }
1407 return list;
1408}
1409
1410
1411//----------------------------------------------------------------------
1412//----------------------------------------------------------------------
1413
1414
1415
1416