]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/helpers.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / helpers.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: helpers.cpp
3 // Purpose: Helper functions/classes for the wxPython extension module
4 //
5 // Author: Robin Dunn
6 //
7 // Created: 1-July-1997
8 // RCS-ID: $Id$
9 // Copyright: (c) 1998 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
12
13
14 #undef DEBUG
15 #include <Python.h>
16 #include "wx/wxPython/wxPython_int.h"
17 #include "wx/wxPython/pyistream.h"
18
19 #ifdef __WXMSW__
20 #include <wx/msw/private.h>
21 #include <wx/msw/winundef.h>
22 #include <wx/msw/msvcrt.h>
23 #endif
24
25 #ifdef __WXGTK__
26 #include <gtk/gtk.h>
27 #include <gdk/gdkprivate.h>
28 #include <wx/gtk/win_gtk.h>
29 #endif
30
31 #ifdef __WXMAC__
32 #include <wx/mac/private.h>
33 #endif
34
35 #include <wx/clipbrd.h>
36 #include <wx/mimetype.h>
37 #include <wx/image.h>
38
39 //----------------------------------------------------------------------
40
41 #if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE
42 #error Python must support Unicode to use wxWindows Unicode
43 #endif
44
45 //----------------------------------------------------------------------
46
47 wxPyApp* wxPythonApp = NULL; // Global instance of application object
48 bool wxPyDoCleanup = False;
49 bool wxPyDoingCleanup = False;
50
51
52 #ifdef WXP_WITH_THREAD
53 struct wxPyThreadState {
54 unsigned long tid;
55 PyThreadState* tstate;
56 int blocked;
57
58 wxPyThreadState(unsigned long _tid=0, PyThreadState* _tstate=NULL)
59 : tid(_tid), tstate(_tstate), blocked(1) {}
60 };
61
62 #include <wx/dynarray.h>
63 WX_DECLARE_OBJARRAY(wxPyThreadState, wxPyThreadStateArray);
64 #include <wx/arrimpl.cpp>
65 WX_DEFINE_OBJARRAY(wxPyThreadStateArray);
66
67 wxPyThreadStateArray* wxPyTStates = NULL;
68 wxMutex* wxPyTMutex = NULL;
69 #endif
70
71
72 static PyObject* wxPython_dict = NULL;
73 static PyObject* wxPyAssertionError = NULL;
74
75 PyObject* wxPyPtrTypeMap = NULL;
76
77
78 #ifdef __WXMSW__ // If building for win32...
79 //----------------------------------------------------------------------
80 // This gets run when the DLL is loaded. We just need to save a handle.
81 //----------------------------------------------------------------------
82
83 BOOL WINAPI DllMain(
84 HINSTANCE hinstDLL, // handle to DLL module
85 DWORD fdwReason, // reason for calling function
86 LPVOID lpvReserved // reserved
87 )
88 {
89 // If wxPython is embedded in another wxWindows app then
90 // the inatance has already been set.
91 if (! wxGetInstance())
92 wxSetInstance(hinstDLL);
93 return True;
94 }
95 #endif
96
97 //----------------------------------------------------------------------
98 // Classes for implementing the wxp main application shell.
99 //----------------------------------------------------------------------
100
101 IMPLEMENT_ABSTRACT_CLASS(wxPyApp, wxApp);
102
103
104 wxPyApp::wxPyApp() {
105 m_assertMode = wxPYAPP_ASSERT_EXCEPTION;
106 m_startupComplete = False;
107 }
108
109
110 wxPyApp::~wxPyApp() {
111 }
112
113
114 // This one isn't acutally called... We fake it with _BootstrapApp
115 bool wxPyApp::OnInit() {
116 return False;
117 }
118
119
120 int wxPyApp::MainLoop() {
121 int retval = 0;
122
123 DeletePendingObjects();
124 bool initialized = wxTopLevelWindows.GetCount() != 0;
125 if (initialized) {
126 if ( m_exitOnFrameDelete == Later ) {
127 m_exitOnFrameDelete = Yes;
128 }
129
130 retval = wxApp::MainLoop();
131 OnExit();
132 }
133 return retval;
134 }
135
136
137 bool wxPyApp::OnInitGui() {
138 bool rval=True;
139 wxApp::OnInitGui(); // in this case always call the base class version
140 wxPyBeginBlockThreads();
141 if (wxPyCBH_findCallback(m_myInst, "OnInitGui"))
142 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
143 wxPyEndBlockThreads();
144 return rval;
145 }
146
147
148 int wxPyApp::OnExit() {
149 int rval=0;
150 wxPyBeginBlockThreads();
151 if (wxPyCBH_findCallback(m_myInst, "OnExit"))
152 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
153 wxPyEndBlockThreads();
154 wxApp::OnExit(); // in this case always call the base class version
155 return rval;
156 }
157
158
159 #ifdef __WXDEBUG__
160 void wxPyApp::OnAssert(const wxChar *file,
161 int line,
162 const wxChar *cond,
163 const wxChar *msg) {
164
165 // if we're not fully initialized then just log the error
166 if (! m_startupComplete) {
167 wxString buf;
168 buf.Alloc(4096);
169 buf.Printf(wxT("%s(%d): assert \"%s\" failed"),
170 file, line, cond);
171 if (msg != NULL) {
172 buf += wxT(": ");
173 buf += msg;
174 }
175 wxLogDebug(buf);
176 return;
177 }
178
179 // If the OnAssert is overloaded in the Python class then call it...
180 bool found;
181 wxPyBeginBlockThreads();
182 if ((found = wxPyCBH_findCallback(m_myInst, "OnAssert"))) {
183 PyObject* fso = wx2PyString(file);
184 PyObject* cso = wx2PyString(file);
185 PyObject* mso;
186 if (msg != NULL)
187 mso = wx2PyString(file);
188 else {
189 mso = Py_None; Py_INCREF(Py_None);
190 }
191 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiOO)", fso, line, cso, mso));
192 Py_DECREF(fso);
193 Py_DECREF(cso);
194 Py_DECREF(mso);
195 }
196 wxPyEndBlockThreads();
197
198 // ...otherwise do our own thing with it
199 if (! found) {
200 // ignore it?
201 if (m_assertMode & wxPYAPP_ASSERT_SUPPRESS)
202 return;
203
204 // turn it into a Python exception?
205 if (m_assertMode & wxPYAPP_ASSERT_EXCEPTION) {
206 wxString buf;
207 buf.Alloc(4096);
208 buf.Printf(wxT("C++ assertion \"%s\" failed in %s(%d)"), cond, file, line);
209 if (msg != NULL) {
210 buf += wxT(": ");
211 buf += msg;
212 }
213
214 // set the exception
215 wxPyBeginBlockThreads();
216 PyObject* s = wx2PyString(buf);
217 PyErr_SetObject(wxPyAssertionError, s);
218 Py_DECREF(s);
219 wxPyEndBlockThreads();
220
221 // Now when control returns to whatever API wrapper was called from
222 // Python it should detect that an exception is set and will return
223 // NULL, signalling the exception to Python.
224 }
225
226 // Send it to the normal log destination, but only if
227 // not _DIALOG because it will call this too
228 if ( (m_assertMode & wxPYAPP_ASSERT_LOG) && !(m_assertMode & wxPYAPP_ASSERT_DIALOG)) {
229 wxString buf;
230 buf.Alloc(4096);
231 buf.Printf(wxT("%s(%d): assert \"%s\" failed"),
232 file, line, cond);
233 if (msg != NULL) {
234 buf += wxT(": ");
235 buf += msg;
236 }
237 wxLogDebug(buf);
238 }
239
240 // do the normal wx assert dialog?
241 if (m_assertMode & wxPYAPP_ASSERT_DIALOG)
242 wxApp::OnAssert(file, line, cond, msg);
243 }
244 }
245 #endif
246
247 // For catching Apple Events
248 void wxPyApp::MacOpenFile(const wxString &fileName)
249 {
250 wxPyBeginBlockThreads();
251 if (wxPyCBH_findCallback(m_myInst, "MacOpenFile")) {
252 PyObject* s = wx2PyString(fileName);
253 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));
254 Py_DECREF(s);
255 }
256 wxPyEndBlockThreads();
257 }
258
259 void wxPyApp::MacPrintFile(const wxString &fileName)
260 {
261 wxPyBeginBlockThreads();
262 if (wxPyCBH_findCallback(m_myInst, "MacPrintFile")) {
263 PyObject* s = wx2PyString(fileName);
264 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s));
265 Py_DECREF(s);
266 }
267 wxPyEndBlockThreads();
268 }
269
270 void wxPyApp::MacNewFile()
271 {
272 wxPyBeginBlockThreads();
273 if (wxPyCBH_findCallback(m_myInst, "MacNewFile"))
274 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
275 wxPyEndBlockThreads();
276 }
277
278 void wxPyApp::MacReopenApp()
279 {
280 wxPyBeginBlockThreads();
281 if (wxPyCBH_findCallback(m_myInst, "MacReopenApp"))
282 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
283 wxPyEndBlockThreads();
284 }
285
286
287 /*static*/
288 bool wxPyApp::GetMacSupportPCMenuShortcuts() {
289 #ifdef __WXMAC__
290 return s_macSupportPCMenuShortcuts;
291 #else
292 return 0;
293 #endif
294 }
295
296 /*static*/
297 long wxPyApp::GetMacAboutMenuItemId() {
298 #ifdef __WXMAC__
299 return s_macAboutMenuItemId;
300 #else
301 return 0;
302 #endif
303 }
304
305 /*static*/
306 long wxPyApp::GetMacPreferencesMenuItemId() {
307 #ifdef __WXMAC__
308 return s_macPreferencesMenuItemId;
309 #else
310 return 0;
311 #endif
312 }
313
314 /*static*/
315 long wxPyApp::GetMacExitMenuItemId() {
316 #ifdef __WXMAC__
317 return s_macExitMenuItemId;
318 #else
319 return 0;
320 #endif
321 }
322
323 /*static*/
324 wxString wxPyApp::GetMacHelpMenuTitleName() {
325 #ifdef __WXMAC__
326 return s_macHelpMenuTitleName;
327 #else
328 return wxEmptyString;
329 #endif
330 }
331
332 /*static*/
333 void wxPyApp::SetMacSupportPCMenuShortcuts(bool val) {
334 #ifdef __WXMAC__
335 s_macSupportPCMenuShortcuts = val;
336 #endif
337 }
338
339 /*static*/
340 void wxPyApp::SetMacAboutMenuItemId(long val) {
341 #ifdef __WXMAC__
342 s_macAboutMenuItemId = val;
343 #endif
344 }
345
346 /*static*/
347 void wxPyApp::SetMacPreferencesMenuItemId(long val) {
348 #ifdef __WXMAC__
349 s_macPreferencesMenuItemId = val;
350 #endif
351 }
352
353 /*static*/
354 void wxPyApp::SetMacExitMenuItemId(long val) {
355 #ifdef __WXMAC__
356 s_macExitMenuItemId = val;
357 #endif
358 }
359
360 /*static*/
361 void wxPyApp::SetMacHelpMenuTitleName(const wxString& val) {
362 #ifdef __WXMAC__
363 s_macHelpMenuTitleName = val;
364 #endif
365 }
366
367
368 // This finishes the initialization of wxWindows and then calls the OnInit
369 // that should be present in the derived (Python) class.
370 void wxPyApp::_BootstrapApp()
371 {
372 bool result;
373 PyObject* retval = NULL;
374 PyObject* pyint = NULL;
375
376
377 // Get any command-line args passed to this program from the sys module
378 int argc = 0;
379 char** argv = NULL;
380 wxPyBeginBlockThreads();
381 PyObject* sysargv = PySys_GetObject("argv");
382 if (sysargv != NULL) {
383 argc = PyList_Size(sysargv);
384 argv = new char*[argc+1];
385 int x;
386 for(x=0; x<argc; x++) {
387 PyObject *pyArg = PyList_GetItem(sysargv, x);
388 argv[x] = PyString_AsString(pyArg);
389 }
390 argv[argc] = NULL;
391 }
392 wxPyEndBlockThreads();
393
394 result = wxEntryStart(argc, argv);
395 delete [] argv;
396
397 wxPyBeginBlockThreads();
398 if (! result) {
399 PyErr_SetString(PyExc_SystemError, "wxEntryStart failed!");
400 goto error;
401 }
402
403 // The stock objects were all NULL when they were loaded into
404 // SWIG generated proxies, so re-init those now...
405 wxPy_ReinitStockObjects(3);
406
407 // It's now ok to generate exceptions for assertion errors.
408 wxPythonApp->SetStartupComplete(True);
409
410 // Call the Python wxApp's OnInit function
411 if (wxPyCBH_findCallback(m_myInst, "OnInit")) {
412
413 PyObject* method = m_myInst.GetLastFound();
414 PyObject* argTuple = PyTuple_New(0);
415 retval = PyEval_CallObject(method, argTuple);
416 Py_DECREF(argTuple);
417 Py_DECREF(method);
418 if (retval == NULL)
419 goto error;
420
421 pyint = PyNumber_Int(retval);
422 if (! pyint) {
423 PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
424 goto error;
425 }
426 result = PyInt_AS_LONG(pyint);
427 }
428 else {
429 // Is it okay if there is no OnInit? Probably so...
430 result = True;
431 }
432
433
434 if (! result) {
435 PyErr_SetString(PyExc_SystemExit, "OnInit returned False, exiting...");
436 }
437
438 error:
439 Py_XDECREF(retval);
440 Py_XDECREF(pyint);
441
442 wxPyEndBlockThreads();
443 };
444
445 //---------------------------------------------------------------------
446 //----------------------------------------------------------------------
447
448
449 #if 0
450 static char* wxPyCopyCString(const wxChar* src)
451 {
452 wxWX2MBbuf buff = (wxWX2MBbuf)wxConvCurrent->cWX2MB(src);
453 size_t len = strlen(buff);
454 char* dest = new char[len+1];
455 strcpy(dest, buff);
456 return dest;
457 }
458
459 #if wxUSE_UNICODE
460 static char* wxPyCopyCString(const char* src) // we need a char version too
461 {
462 size_t len = strlen(src);
463 char* dest = new char[len+1];
464 strcpy(dest, src);
465 return dest;
466 }
467 #endif
468
469 static wxChar* wxPyCopyWString(const char *src)
470 {
471 //wxMB2WXbuf buff = wxConvCurrent->cMB2WX(src);
472 wxString str(src, *wxConvCurrent);
473 return copystring(str);
474 }
475
476 #if wxUSE_UNICODE
477 static wxChar* wxPyCopyWString(const wxChar *src)
478 {
479 return copystring(src);
480 }
481 #endif
482 #endif
483
484
485 inline const char* dropwx(const char* name) {
486 if (name[0] == 'w' && name[1] == 'x')
487 return name+2;
488 else
489 return name;
490 }
491
492 //----------------------------------------------------------------------
493
494 // This function is called when the wxc module is imported to do some initial
495 // setup. (Before there is a wxApp object.) The rest happens in
496 // wxPyApp::_BootstrapApp
497 void __wxPyPreStart(PyObject* moduleDict)
498 {
499
500 #ifdef __WXMSW__
501 // wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
502 #endif
503
504 #ifdef WXP_WITH_THREAD
505 PyEval_InitThreads();
506 wxPyTStates = new wxPyThreadStateArray;
507 wxPyTMutex = new wxMutex;
508
509 // Save the current (main) thread state in our array
510 PyThreadState* tstate = wxPyBeginAllowThreads();
511 wxPyEndAllowThreads(tstate);
512 #endif
513
514 // Ensure that the build options in the DLL (or whatever) match this build
515 wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "wxPython");
516
517 // Init the stock objects to a non-NULL value so SWIG doesn't create them as None
518 wxPy_ReinitStockObjects(1);
519 }
520
521
522
523 void __wxPyCleanup() {
524 wxPyDoingCleanup = True;
525 if (wxPyDoCleanup) {
526 wxPyDoCleanup = False;
527 wxEntryCleanup();
528 }
529 #ifdef WXP_WITH_THREAD
530 delete wxPyTMutex;
531 wxPyTMutex = NULL;
532 wxPyTStates->Empty();
533 delete wxPyTStates;
534 wxPyTStates = NULL;
535 #endif
536 }
537
538
539 // Save a reference to the dictionary of the wx.core module, and inject
540 // a few more things into it.
541 PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args)
542 {
543
544 if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
545 return NULL;
546
547 if (!PyDict_Check(wxPython_dict)) {
548 PyErr_SetString(PyExc_TypeError, "_wxPySetDictionary must have dictionary object!");
549 return NULL;
550 }
551
552 if (! wxPyPtrTypeMap)
553 wxPyPtrTypeMap = PyDict_New();
554 PyDict_SetItemString(wxPython_dict, "__wxPyPtrTypeMap", wxPyPtrTypeMap);
555
556 // Create an exception object to use for wxASSERTions
557 wxPyAssertionError = PyErr_NewException("wx.core.PyAssertionError",
558 PyExc_AssertionError, NULL);
559 PyDict_SetItemString(wxPython_dict, "PyAssertionError", wxPyAssertionError);
560
561
562 #ifdef __WXMOTIF__
563 #define wxPlatform "__WXMOTIF__"
564 #endif
565 #ifdef __WXX11__
566 #define wxPlatform "__WXX11__"
567 #endif
568 #ifdef __WXGTK__
569 #define wxPlatform "__WXGTK__"
570 #endif
571 #if defined(__WIN32__) || defined(__WXMSW__)
572 #define wxPlatform "__WXMSW__"
573 #endif
574 #ifdef __WXMAC__
575 #define wxPlatform "__WXMAC__"
576 #endif
577
578 #ifdef __WXDEBUG__
579 int wxdebug = 1;
580 #else
581 int wxdebug = 0;
582 #endif
583
584 PyDict_SetItemString(wxPython_dict, "Platform", PyString_FromString(wxPlatform));
585 PyDict_SetItemString(wxPython_dict, "USE_UNICODE", PyInt_FromLong(wxUSE_UNICODE));
586 PyDict_SetItemString(wxPython_dict, "__WXDEBUG__", PyInt_FromLong(wxdebug));
587
588 RETURN_NONE();
589 }
590
591
592 //---------------------------------------------------------------------------
593
594 // Python's PyInstance_Check does not return True for instances of new-style
595 // classes. This should get close enough for both new and old classes but I
596 // should re-evaluate the need for doing instance checks...
597 bool wxPyInstance_Check(PyObject* obj) {
598 return PyObject_HasAttrString(obj, "__class__") != 0;
599 }
600
601
602 // This one checks if the object is an instance of a SWIG proxy class (it has
603 // a .this attribute)
604 bool wxPySwigInstance_Check(PyObject* obj) {
605 return PyObject_HasAttrString(obj, "this") != 0;
606 }
607
608 //---------------------------------------------------------------------------
609
610 // The stock objects are no longer created when the wxc module is imported,
611 // but only after the app object has been created. The
612 // wxPy_ReinitStockObjects function will be called 3 times to pass the stock
613 // objects though various stages of evolution:
614 //
615 // pass 1: Set all the pointers to a non-NULL value so the Python proxy
616 // object will be created (otherwise it will just use None.)
617 //
618 // pass 2: After the module has been imported and the python proxys have
619 // been created, then set the __class__ to be _wxPyUnbornObject so
620 // it will catch any access to the object and will raise an exception.
621 //
622 // pass 3: Finally, from OnInit patch things up so the stock objects can
623 // be used.
624
625
626 PyObject* __wxPyFixStockObjects(PyObject* /* self */, PyObject* args)
627 {
628 wxPy_ReinitStockObjects(2);
629 RETURN_NONE();
630 }
631
632
633 static void rsoPass2(const char* name)
634 {
635 static PyObject* unbornObjectClass = NULL;
636 PyObject* obj;
637
638 if (unbornObjectClass == NULL) {
639 unbornObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyUnbornObject");
640 Py_INCREF(unbornObjectClass);
641 }
642
643 // Find the object instance
644 obj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(name));
645 wxCHECK_RET(obj != NULL, wxT("Unable to find stock object"));
646 wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance"));
647
648 // Change its class
649 PyObject_SetAttrString(obj, "__class__", unbornObjectClass);
650
651 }
652
653 static void rsoPass3(const char* name, const char* classname, void* ptr)
654 {
655 PyObject* obj;
656 PyObject* classobj;
657 PyObject* ptrobj;
658
659 // Find the object instance
660 obj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(name));
661 wxCHECK_RET(obj != NULL, wxT("Unable to find stock object"));
662 wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance"));
663
664 // Find the class object and put it back in the instance
665 classobj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(classname));
666 wxCHECK_RET(classobj != NULL, wxT("Unable to find stock class object"));
667 PyObject_SetAttrString(obj, "__class__", classobj);
668
669 // Rebuild the .this swigified pointer with the new value of the C++ pointer
670 ptrobj = wxPyMakeSwigPtr(ptr, wxString(classname, *wxConvCurrent));
671 PyObject_SetAttrString(obj, "this", ptrobj);
672 Py_DECREF(ptrobj);
673 }
674
675
676
677 void wxPy_ReinitStockObjects(int pass)
678 {
679
680 #define REINITOBJ(name, classname) \
681 if (pass == 1) { name = (classname*)0xC0C0C0C0; } \
682 else if (pass == 2) { rsoPass2(#name); } \
683 else if (pass == 3) { rsoPass3(#name, #classname, (void*)name); }
684
685
686 #define REINITOBJ2(name, classname) \
687 if (pass == 1) { } \
688 else if (pass == 2) { rsoPass2(#name); } \
689 else if (pass == 3) { rsoPass3(#name, #classname, (void*)&name); }
690
691
692 REINITOBJ(wxNORMAL_FONT, wxFont);
693 REINITOBJ(wxSMALL_FONT, wxFont);
694 REINITOBJ(wxITALIC_FONT, wxFont);
695 REINITOBJ(wxSWISS_FONT, wxFont);
696
697 REINITOBJ(wxRED_PEN, wxPen);
698 REINITOBJ(wxCYAN_PEN, wxPen);
699 REINITOBJ(wxGREEN_PEN, wxPen);
700 REINITOBJ(wxBLACK_PEN, wxPen);
701 REINITOBJ(wxWHITE_PEN, wxPen);
702 REINITOBJ(wxTRANSPARENT_PEN, wxPen);
703 REINITOBJ(wxBLACK_DASHED_PEN, wxPen);
704 REINITOBJ(wxGREY_PEN, wxPen);
705 REINITOBJ(wxMEDIUM_GREY_PEN, wxPen);
706 REINITOBJ(wxLIGHT_GREY_PEN, wxPen);
707
708 REINITOBJ(wxBLUE_BRUSH, wxBrush);
709 REINITOBJ(wxGREEN_BRUSH, wxBrush);
710 REINITOBJ(wxWHITE_BRUSH, wxBrush);
711 REINITOBJ(wxBLACK_BRUSH, wxBrush);
712 REINITOBJ(wxTRANSPARENT_BRUSH, wxBrush);
713 REINITOBJ(wxCYAN_BRUSH, wxBrush);
714 REINITOBJ(wxRED_BRUSH, wxBrush);
715 REINITOBJ(wxGREY_BRUSH, wxBrush);
716 REINITOBJ(wxMEDIUM_GREY_BRUSH, wxBrush);
717 REINITOBJ(wxLIGHT_GREY_BRUSH, wxBrush);
718
719 REINITOBJ(wxBLACK, wxColour);
720 REINITOBJ(wxWHITE, wxColour);
721 REINITOBJ(wxRED, wxColour);
722 REINITOBJ(wxBLUE, wxColour);
723 REINITOBJ(wxGREEN, wxColour);
724 REINITOBJ(wxCYAN, wxColour);
725 REINITOBJ(wxLIGHT_GREY, wxColour);
726
727 REINITOBJ(wxSTANDARD_CURSOR, wxCursor);
728 REINITOBJ(wxHOURGLASS_CURSOR, wxCursor);
729 REINITOBJ(wxCROSS_CURSOR, wxCursor);
730
731 REINITOBJ2(wxNullBitmap, wxBitmap);
732 REINITOBJ2(wxNullIcon, wxIcon);
733 REINITOBJ2(wxNullCursor, wxCursor);
734 REINITOBJ2(wxNullPen, wxPen);
735 REINITOBJ2(wxNullBrush, wxBrush);
736 REINITOBJ2(wxNullPalette, wxPalette);
737 REINITOBJ2(wxNullFont, wxFont);
738 REINITOBJ2(wxNullColour, wxColour);
739
740 REINITOBJ(wxTheFontList, wxFontList);
741 REINITOBJ(wxThePenList, wxPenList);
742 REINITOBJ(wxTheBrushList, wxBrushList);
743 REINITOBJ(wxTheColourDatabase, wxColourDatabase);
744
745
746 REINITOBJ(wxTheClipboard, wxClipboard);
747 REINITOBJ2(wxDefaultValidator, wxValidator);
748 REINITOBJ2(wxNullImage, wxImage);
749 REINITOBJ2(wxNullAcceleratorTable, wxAcceleratorTable);
750
751 #undef REINITOBJ
752 #undef REINITOBJ2
753 }
754
755 //---------------------------------------------------------------------------
756
757 void wxPyClientData_dtor(wxPyClientData* self) {
758 if (! wxPyDoingCleanup) { // Don't do it during cleanup as Python
759 // may have already garbage collected the object...
760 wxPyBeginBlockThreads();
761 Py_DECREF(self->m_obj);
762 self->m_obj = NULL;
763 wxPyEndBlockThreads();
764 }
765 }
766
767 void wxPyUserData_dtor(wxPyUserData* self) {
768 if (! wxPyDoingCleanup) {
769 wxPyBeginBlockThreads();
770 Py_DECREF(self->m_obj);
771 self->m_obj = NULL;
772 wxPyEndBlockThreads();
773 }
774 }
775
776
777 // This is called when an OOR controled object is being destroyed. Although
778 // the C++ object is going away there is no way to force the Python object
779 // (and all references to it) to die too. This causes problems (crashes) in
780 // wxPython when a python shadow object attempts to call a C++ method using
781 // the now bogus pointer... So to try and prevent this we'll do a little black
782 // magic and change the class of the python instance to a class that will
783 // raise an exception for any attempt to call methods with it. See
784 // _wxPyDeadObject in _core_ex.py for the implementation of this class.
785 void wxPyOORClientData_dtor(wxPyOORClientData* self) {
786
787 static PyObject* deadObjectClass = NULL;
788
789 wxPyBeginBlockThreads();
790 if (deadObjectClass == NULL) {
791 deadObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyDeadObject");
792 // TODO: Can not wxASSERT here because inside a wxPyBeginBlock Threads,
793 // will lead to a deadlock when it tries to aquire the GIL again.
794 //wxASSERT_MSG(deadObjectClass != NULL, wxT("Can't get _wxPyDeadObject class!"));
795 Py_INCREF(deadObjectClass);
796 }
797
798
799 // Only if there is more than one reference to the object
800 if ( !wxPyDoingCleanup && self->m_obj->ob_refcnt > 1 ) {
801 // bool isInstance = wxPyInstance_Check(self->m_obj);
802 // TODO same here
803 //wxASSERT_MSG(isInstance, wxT("m_obj not an instance!?!?!"));
804
805 // Call __del__, if there is one.
806 PyObject* func = PyObject_GetAttrString(self->m_obj, "__del__");
807 if (func) {
808 PyObject* rv = PyObject_CallMethod(self->m_obj, "__del__", NULL);
809 Py_XDECREF(rv);
810 Py_DECREF(func);
811 }
812 if (PyErr_Occurred())
813 PyErr_Clear(); // just ignore it for now
814
815
816 PyObject* dict = PyObject_GetAttrString(self->m_obj, "__dict__");
817 if (dict) {
818 // Clear the instance's dictionary
819 PyDict_Clear(dict);
820
821 // put the name of the old class into the instance, and then reset the
822 // class to be the dead class.
823 PyObject* klass = PyObject_GetAttrString(self->m_obj, "__class__");
824 PyObject* name = PyObject_GetAttrString(klass, "__name__");
825 PyDict_SetItemString(dict, "_name", name);
826 PyObject_SetAttrString(self->m_obj, "__class__", deadObjectClass);
827 //Py_INCREF(deadObjectClass);
828 Py_DECREF(klass);
829 Py_DECREF(name);
830 }
831 }
832
833 // m_obj is DECREF'd in the base class dtor...
834 wxPyEndBlockThreads();
835 }
836
837
838 //---------------------------------------------------------------------------
839 // Stuff used by OOR to find the right wxPython class type to return and to
840 // build it.
841
842
843 // The pointer type map is used when the "pointer" type name generated by SWIG
844 // is not the same as the shadow class name, for example wxPyTreeCtrl
845 // vs. wxTreeCtrl. It needs to be referenced in Python as well as from C++,
846 // so we'll just make it a Python dictionary in the wx module's namespace.
847 // (See __wxSetDictionary)
848 void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
849 if (! wxPyPtrTypeMap)
850 wxPyPtrTypeMap = PyDict_New();
851 PyDict_SetItemString(wxPyPtrTypeMap,
852 (char*)commonName,
853 PyString_FromString((char*)ptrName));
854 }
855
856
857
858
859 PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
860 PyObject* target = NULL;
861 bool isEvtHandler = False;
862
863 if (source) {
864 // If it's derived from wxEvtHandler then there may
865 // already be a pointer to a Python object that we can use
866 // in the OOR data.
867 if (checkEvtHandler && wxIsKindOf(source, wxEvtHandler)) {
868 isEvtHandler = True;
869 wxEvtHandler* eh = (wxEvtHandler*)source;
870 wxPyOORClientData* data = (wxPyOORClientData*)eh->GetClientObject();
871 if (data) {
872 target = data->m_obj;
873 if (target)
874 Py_INCREF(target);
875 }
876 }
877
878 if (! target) {
879 // Otherwise make it the old fashioned way by making a new shadow
880 // object and putting this pointer in it. Look up the class
881 // heirarchy until we find a class name that is located in the
882 // python module.
883 const wxClassInfo* info = source->GetClassInfo();
884 wxString name = info->GetClassName();
885 bool exists = wxPyCheckSwigType(name);
886 while (info && !exists) {
887 info = info->GetBaseClass1();
888 name = info->GetClassName();
889 exists = wxPyCheckSwigType(name);
890 }
891 if (info) {
892 target = wxPyConstructObject((void*)source, name, False);
893 if (target && isEvtHandler)
894 ((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target));
895 } else {
896 wxString msg(wxT("wxPython class not found for "));
897 msg += source->GetClassInfo()->GetClassName();
898 PyErr_SetString(PyExc_NameError, msg.mbc_str());
899 target = NULL;
900 }
901 }
902 } else { // source was NULL so return None.
903 Py_INCREF(Py_None); target = Py_None;
904 }
905 return target;
906 }
907
908
909 PyObject* wxPyMake_wxSizer(wxSizer* source) {
910 PyObject* target = NULL;
911
912 if (source && wxIsKindOf(source, wxSizer)) {
913 // If it's derived from wxSizer then there may already be a pointer to
914 // a Python object that we can use in the OOR data.
915 wxSizer* sz = (wxSizer*)source;
916 wxPyOORClientData* data = (wxPyOORClientData*)sz->GetClientObject();
917 if (data) {
918 target = data->m_obj;
919 if (target)
920 Py_INCREF(target);
921 }
922 }
923 if (! target) {
924 target = wxPyMake_wxObject(source, False);
925 if (target != Py_None)
926 ((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target));
927 }
928 return target;
929 }
930
931
932 //---------------------------------------------------------------------------
933
934
935 #ifdef WXP_WITH_THREAD
936 inline
937 unsigned long wxPyGetCurrentThreadId() {
938 return wxThread::GetCurrentId();
939 }
940
941 static wxPyThreadState gs_shutdownTState;
942
943 static
944 wxPyThreadState* wxPyGetThreadState() {
945 if (wxPyTMutex == NULL) // Python is shutting down...
946 return &gs_shutdownTState;
947
948 unsigned long ctid = wxPyGetCurrentThreadId();
949 wxPyThreadState* tstate = NULL;
950
951 wxPyTMutex->Lock();
952 for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
953 wxPyThreadState& info = wxPyTStates->Item(i);
954 if (info.tid == ctid) {
955 tstate = &info;
956 break;
957 }
958 }
959 wxPyTMutex->Unlock();
960 wxASSERT_MSG(tstate, wxT("PyThreadState should not be NULL!"));
961 return tstate;
962 }
963
964
965 static
966 void wxPySaveThreadState(PyThreadState* tstate) {
967 if (wxPyTMutex == NULL) { // Python is shutting down, assume a single thread...
968 gs_shutdownTState.tstate = tstate;
969 return;
970 }
971 unsigned long ctid = wxPyGetCurrentThreadId();
972 wxPyTMutex->Lock();
973 for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
974 wxPyThreadState& info = wxPyTStates->Item(i);
975 if (info.tid == ctid) {
976 #if 0
977 if (info.tstate != tstate)
978 wxLogMessage("*** tstate mismatch!???");
979 #endif
980 // info.tstate = tstate; *** DO NOT update existing ones???
981 // Normally it will never change, but apparently COM callbacks
982 // (i.e. ActiveX controls) will (incorrectly IMHO) use a transient
983 // tstate which will then be garbage the next time we try to use
984 // it...
985 wxPyTMutex->Unlock();
986 return;
987 }
988 }
989 // not found, so add it...
990 wxPyTStates->Add(new wxPyThreadState(ctid, tstate));
991 wxPyTMutex->Unlock();
992 }
993
994 #endif
995
996
997
998 // Calls from Python to wxWindows code are wrapped in calls to these
999 // functions:
1000
1001 PyThreadState* wxPyBeginAllowThreads() {
1002 #ifdef WXP_WITH_THREAD
1003 PyThreadState* saved = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS;
1004 wxPySaveThreadState(saved);
1005 wxPyGetThreadState()->blocked -= 1;
1006 return saved;
1007 #else
1008 return NULL;
1009 #endif
1010 }
1011
1012 void wxPyEndAllowThreads(PyThreadState* saved) {
1013 #ifdef WXP_WITH_THREAD
1014 wxPyGetThreadState()->blocked += 1;
1015 PyEval_RestoreThread(saved); // Py_END_ALLOW_THREADS;
1016 #endif
1017 }
1018
1019
1020
1021 // Calls from wxWindows back to Python code, or even any PyObject
1022 // manipulations, PyDECREF's and etc. are wrapped in calls to these functions:
1023
1024 void wxPyBeginBlockThreads() {
1025 #ifdef WXP_WITH_THREAD
1026 wxPyThreadState* tstate = wxPyGetThreadState();
1027 if (tstate->blocked++ == 0) { // if nested calls then do nothing
1028 PyEval_RestoreThread(tstate->tstate);
1029 }
1030 #endif
1031 }
1032
1033
1034 void wxPyEndBlockThreads() {
1035 #ifdef WXP_WITH_THREAD
1036 wxPyThreadState* tstate = wxPyGetThreadState();
1037 tstate->blocked -= 1;
1038 if ( tstate->blocked == 0) { // if nested calls then do nothing
1039 PyEval_SaveThread();
1040 }
1041 #endif
1042 }
1043
1044
1045 //---------------------------------------------------------------------------
1046 // wxPyInputStream and wxPyCBInputStream methods
1047
1048
1049 void wxPyInputStream::close() {
1050 /* do nothing for now */
1051 }
1052
1053 void wxPyInputStream::flush() {
1054 /* do nothing for now */
1055 }
1056
1057 bool wxPyInputStream::eof() {
1058 if (m_wxis)
1059 return m_wxis->Eof();
1060 else
1061 return True;
1062 }
1063
1064 wxPyInputStream::~wxPyInputStream() {
1065 /* do nothing */
1066 }
1067
1068
1069
1070
1071 PyObject* wxPyInputStream::read(int size) {
1072 PyObject* obj = NULL;
1073 wxMemoryBuffer buf;
1074 const int BUFSIZE = 1024;
1075
1076 // check if we have a real wxInputStream to work with
1077 if (!m_wxis) {
1078 wxPyBeginBlockThreads();
1079 PyErr_SetString(PyExc_IOError, "no valid C-wxInputStream");
1080 wxPyEndBlockThreads();
1081 return NULL;
1082 }
1083
1084 if (size < 0) {
1085 // read while bytes are available on the stream
1086 while ( m_wxis->CanRead() ) {
1087 m_wxis->Read(buf.GetAppendBuf(BUFSIZE), BUFSIZE);
1088 buf.UngetAppendBuf(m_wxis->LastRead());
1089 }
1090
1091 } else { // Read only size number of characters
1092 m_wxis->Read(buf.GetWriteBuf(size), size);
1093 buf.UngetWriteBuf(m_wxis->LastRead());
1094 }
1095
1096 // error check
1097 wxPyBeginBlockThreads();
1098 wxStreamError err = m_wxis->GetLastError();
1099 if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) {
1100 PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
1101 }
1102 else {
1103 // We use only strings for the streams, not unicode
1104 obj = PyString_FromStringAndSize(buf, buf.GetDataLen());
1105 }
1106 wxPyEndBlockThreads();
1107 return obj;
1108 }
1109
1110
1111 PyObject* wxPyInputStream::readline(int size) {
1112 PyObject* obj = NULL;
1113 wxMemoryBuffer buf;
1114 int i;
1115 char ch;
1116
1117 // check if we have a real wxInputStream to work with
1118 if (!m_wxis) {
1119 wxPyBeginBlockThreads();
1120 PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream");
1121 wxPyEndBlockThreads();
1122 return NULL;
1123 }
1124
1125 // read until \n or byte limit reached
1126 for (i=ch=0; (ch != '\n') && (m_wxis->CanRead()) && ((size < 0) || (i < size)); i++) {
1127 ch = m_wxis->GetC();
1128 buf.AppendByte(ch);
1129 }
1130
1131 // errorcheck
1132 wxPyBeginBlockThreads();
1133 wxStreamError err = m_wxis->GetLastError();
1134 if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) {
1135 PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
1136 }
1137 else {
1138 // We use only strings for the streams, not unicode
1139 obj = PyString_FromStringAndSize((char*)buf.GetData(), buf.GetDataLen());
1140 }
1141 wxPyEndBlockThreads();
1142 return obj;
1143 }
1144
1145
1146 PyObject* wxPyInputStream::readlines(int sizehint) {
1147 PyObject* pylist;
1148
1149 // check if we have a real wxInputStream to work with
1150 if (!m_wxis) {
1151 wxPyBeginBlockThreads();
1152 PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream");
1153 wxPyEndBlockThreads();
1154 return NULL;
1155 }
1156
1157 // init list
1158 wxPyBeginBlockThreads();
1159 pylist = PyList_New(0);
1160 if (!pylist) {
1161 wxPyBeginBlockThreads();
1162 PyErr_NoMemory();
1163 wxPyEndBlockThreads();
1164 return NULL;
1165 }
1166
1167 // read sizehint bytes or until EOF
1168 int i;
1169 for (i=0; (m_wxis->CanRead()) && ((sizehint < 0) || (i < sizehint));) {
1170 PyObject* s = this->readline();
1171 if (s == NULL) {
1172 wxPyBeginBlockThreads();
1173 Py_DECREF(pylist);
1174 wxPyEndBlockThreads();
1175 return NULL;
1176 }
1177 wxPyBeginBlockThreads();
1178 PyList_Append(pylist, s);
1179 i += PyString_Size(s);
1180 wxPyEndBlockThreads();
1181 }
1182
1183 // error check
1184 wxStreamError err = m_wxis->GetLastError();
1185 if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) {
1186 wxPyBeginBlockThreads();
1187 Py_DECREF(pylist);
1188 PyErr_SetString(PyExc_IOError,"IOError in wxInputStream");
1189 wxPyEndBlockThreads();
1190 return NULL;
1191 }
1192
1193 return pylist;
1194 }
1195
1196
1197 void wxPyInputStream::seek(int offset, int whence) {
1198 if (m_wxis)
1199 m_wxis->SeekI(offset, wxSeekMode(whence));
1200 }
1201
1202 int wxPyInputStream::tell(){
1203 if (m_wxis)
1204 return m_wxis->TellI();
1205 else return 0;
1206 }
1207
1208
1209
1210
1211 wxPyCBInputStream::wxPyCBInputStream(PyObject *r, PyObject *s, PyObject *t, bool block)
1212 : wxInputStream(), m_read(r), m_seek(s), m_tell(t), m_block(block)
1213 {}
1214
1215
1216 wxPyCBInputStream::~wxPyCBInputStream() {
1217 if (m_block) wxPyBeginBlockThreads();
1218 Py_XDECREF(m_read);
1219 Py_XDECREF(m_seek);
1220 Py_XDECREF(m_tell);
1221 if (m_block) wxPyEndBlockThreads();
1222 }
1223
1224
1225 wxPyCBInputStream* wxPyCBInputStream::create(PyObject *py, bool block) {
1226 if (block) wxPyBeginBlockThreads();
1227
1228 PyObject* read = getMethod(py, "read");
1229 PyObject* seek = getMethod(py, "seek");
1230 PyObject* tell = getMethod(py, "tell");
1231
1232 if (!read) {
1233 PyErr_SetString(PyExc_TypeError, "Not a file-like object");
1234 Py_XDECREF(read);
1235 Py_XDECREF(seek);
1236 Py_XDECREF(tell);
1237 if (block) wxPyEndBlockThreads();
1238 return NULL;
1239 }
1240
1241 if (block) wxPyEndBlockThreads();
1242 return new wxPyCBInputStream(read, seek, tell, block);
1243 }
1244
1245
1246 wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block) {
1247 return wxPyCBInputStream::create(py, block);
1248 }
1249
1250 PyObject* wxPyCBInputStream::getMethod(PyObject* py, char* name) {
1251 if (!PyObject_HasAttrString(py, name))
1252 return NULL;
1253 PyObject* o = PyObject_GetAttrString(py, name);
1254 if (!PyMethod_Check(o) && !PyCFunction_Check(o)) {
1255 Py_DECREF(o);
1256 return NULL;
1257 }
1258 return o;
1259 }
1260
1261
1262 size_t wxPyCBInputStream::GetSize() const {
1263 wxPyCBInputStream* self = (wxPyCBInputStream*)this; // cast off const
1264 if (m_seek && m_tell) {
1265 off_t temp = self->OnSysTell();
1266 off_t ret = self->OnSysSeek(0, wxFromEnd);
1267 self->OnSysSeek(temp, wxFromStart);
1268 return ret;
1269 }
1270 else
1271 return 0;
1272 }
1273
1274
1275 size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) {
1276 if (bufsize == 0)
1277 return 0;
1278
1279 wxPyBeginBlockThreads();
1280 PyObject* arglist = Py_BuildValue("(i)", bufsize);
1281 PyObject* result = PyEval_CallObject(m_read, arglist);
1282 Py_DECREF(arglist);
1283
1284 size_t o = 0;
1285 if ((result != NULL) && PyString_Check(result)) {
1286 o = PyString_Size(result);
1287 if (o == 0)
1288 m_lasterror = wxSTREAM_EOF;
1289 if (o > bufsize)
1290 o = bufsize;
1291 memcpy((char*)buffer, PyString_AsString(result), o); // strings only, not unicode...
1292 Py_DECREF(result);
1293
1294 }
1295 else
1296 m_lasterror = wxSTREAM_READ_ERROR;
1297 wxPyEndBlockThreads();
1298 return o;
1299 }
1300
1301 size_t wxPyCBInputStream::OnSysWrite(const void *buffer, size_t bufsize) {
1302 m_lasterror = wxSTREAM_WRITE_ERROR;
1303 return 0;
1304 }
1305
1306 off_t wxPyCBInputStream::OnSysSeek(off_t off, wxSeekMode mode) {
1307 wxPyBeginBlockThreads();
1308 #ifdef _LARGE_FILES
1309 // off_t is a 64-bit value...
1310 PyObject* arglist = Py_BuildValue("(Li)", off, mode);
1311 #else
1312 PyObject* arglist = Py_BuildValue("(ii)", off, mode);
1313 #endif
1314 PyObject* result = PyEval_CallObject(m_seek, arglist);
1315 Py_DECREF(arglist);
1316 Py_XDECREF(result);
1317 wxPyEndBlockThreads();
1318 return OnSysTell();
1319 }
1320
1321
1322 off_t wxPyCBInputStream::OnSysTell() const {
1323 wxPyBeginBlockThreads();
1324 PyObject* arglist = Py_BuildValue("()");
1325 PyObject* result = PyEval_CallObject(m_tell, arglist);
1326 Py_DECREF(arglist);
1327 off_t o = 0;
1328 if (result != NULL) {
1329 #ifdef _LARGE_FILES
1330 if (PyLong_Check(result))
1331 o = PyLong_AsLongLong(result);
1332 else
1333 #endif
1334 o = PyInt_AsLong(result);
1335 Py_DECREF(result);
1336 };
1337 wxPyEndBlockThreads();
1338 return o;
1339 }
1340
1341 //----------------------------------------------------------------------
1342
1343 IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
1344
1345 wxPyCallback::wxPyCallback(PyObject* func) {
1346 m_func = func;
1347 Py_INCREF(m_func);
1348 }
1349
1350 wxPyCallback::wxPyCallback(const wxPyCallback& other) {
1351 m_func = other.m_func;
1352 Py_INCREF(m_func);
1353 }
1354
1355 wxPyCallback::~wxPyCallback() {
1356 wxPyBeginBlockThreads();
1357 Py_DECREF(m_func);
1358 wxPyEndBlockThreads();
1359 }
1360
1361
1362
1363 // This function is used for all events destined for Python event handlers.
1364 void wxPyCallback::EventThunker(wxEvent& event) {
1365 wxPyCallback* cb = (wxPyCallback*)event.m_callbackUserData;
1366 PyObject* func = cb->m_func;
1367 PyObject* result;
1368 PyObject* arg;
1369 PyObject* tuple;
1370 bool checkSkip = False;
1371
1372 wxPyBeginBlockThreads();
1373 wxString className = event.GetClassInfo()->GetClassName();
1374
1375 // If the event is one of these types then pass the original
1376 // event object instead of the one passed to us.
1377 if ( className == wxT("wxPyEvent") ) {
1378 arg = ((wxPyEvent*)&event)->GetSelf();
1379 checkSkip = ((wxPyEvent*)&event)->GetCloned();
1380 }
1381 else if ( className == wxT("wxPyCommandEvent") ) {
1382 arg = ((wxPyCommandEvent*)&event)->GetSelf();
1383 checkSkip = ((wxPyCommandEvent*)&event)->GetCloned();
1384 }
1385 else {
1386 arg = wxPyConstructObject((void*)&event, className);
1387 }
1388
1389 if (!arg) {
1390 PyErr_Print();
1391 } else {
1392 // Call the event handler, passing the event object
1393 tuple = PyTuple_New(1);
1394 PyTuple_SET_ITEM(tuple, 0, arg); // steals ref to arg
1395 result = PyEval_CallObject(func, tuple);
1396 if ( result ) {
1397 Py_DECREF(result); // result is ignored, but we still need to decref it
1398 PyErr_Clear(); // Just in case...
1399 } else {
1400 PyErr_Print();
1401 }
1402
1403 if ( checkSkip ) {
1404 // if the event object was one of our special types and
1405 // it had been cloned, then we need to extract the Skipped
1406 // value from the original and set it in the clone.
1407 result = PyObject_CallMethod(arg, "GetSkipped", "");
1408 if ( result ) {
1409 event.Skip(PyInt_AsLong(result));
1410 Py_DECREF(result);
1411 } else {
1412 PyErr_Print();
1413 }
1414 }
1415 Py_DECREF(tuple);
1416 }
1417 wxPyEndBlockThreads();
1418 }
1419
1420
1421 //----------------------------------------------------------------------
1422
1423 wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) {
1424 m_lastFound = NULL;
1425 m_self = other.m_self;
1426 m_class = other.m_class;
1427 if (m_self) {
1428 Py_INCREF(m_self);
1429 Py_INCREF(m_class);
1430 }
1431 }
1432
1433
1434 void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* klass, int incref) {
1435 m_self = self;
1436 m_class = klass;
1437 m_incRef = incref;
1438 if (incref) {
1439 Py_INCREF(m_self);
1440 Py_INCREF(m_class);
1441 }
1442 }
1443
1444
1445 #if PYTHON_API_VERSION >= 1011
1446
1447 // Prior to Python 2.2 PyMethod_GetClass returned the class object
1448 // in which the method was defined. Starting with 2.2 it returns
1449 // "class that asked for the method" which seems totally bogus to me
1450 // but apprently it fixes some obscure problem waiting to happen in
1451 // Python. Since the API was not documented Guido and the gang felt
1452 // safe in changing it. Needless to say that totally screwed up the
1453 // logic below in wxPyCallbackHelper::findCallback, hence this icky
1454 // code to find the class where the method is actually defined...
1455
1456 static
1457 PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name)
1458 {
1459 int i, n;
1460
1461 if (PyType_Check(klass)) { // new style classes
1462 // This code is borrowed/adapted from _PyType_Lookup in typeobject.c
1463 PyTypeObject* type = (PyTypeObject*)klass;
1464 PyObject *mro, *res, *base, *dict;
1465 /* Look in tp_dict of types in MRO */
1466 mro = type->tp_mro;
1467 assert(PyTuple_Check(mro));
1468 n = PyTuple_GET_SIZE(mro);
1469 for (i = 0; i < n; i++) {
1470 base = PyTuple_GET_ITEM(mro, i);
1471 if (PyClass_Check(base))
1472 dict = ((PyClassObject *)base)->cl_dict;
1473 else {
1474 assert(PyType_Check(base));
1475 dict = ((PyTypeObject *)base)->tp_dict;
1476 }
1477 assert(dict && PyDict_Check(dict));
1478 res = PyDict_GetItem(dict, name);
1479 if (res != NULL)
1480 return base;
1481 }
1482 return NULL;
1483 }
1484
1485 else if (PyClass_Check(klass)) { // old style classes
1486 // This code is borrowed/adapted from class_lookup in classobject.c
1487 PyClassObject* cp = (PyClassObject*)klass;
1488 PyObject *value = PyDict_GetItem(cp->cl_dict, name);
1489 if (value != NULL) {
1490 return (PyObject*)cp;
1491 }
1492 n = PyTuple_Size(cp->cl_bases);
1493 for (i = 0; i < n; i++) {
1494 PyObject* base = PyTuple_GetItem(cp->cl_bases, i);
1495 PyObject *v = PyFindClassWithAttr(base, name);
1496 if (v != NULL)
1497 return v;
1498 }
1499 return NULL;
1500 }
1501 return NULL;
1502 }
1503 #endif
1504
1505
1506 static
1507 PyObject* PyMethod_GetDefiningClass(PyObject* method, const char* name)
1508 {
1509 PyObject* mgc = PyMethod_GET_CLASS(method);
1510
1511 #if PYTHON_API_VERSION <= 1010 // prior to Python 2.2, the easy way
1512 return mgc;
1513 #else // 2.2 and after, the hard way...
1514
1515 PyObject* nameo = PyString_FromString(name);
1516 PyObject* klass = PyFindClassWithAttr(mgc, nameo);
1517 Py_DECREF(nameo);
1518 return klass;
1519 #endif
1520 }
1521
1522
1523
1524 bool wxPyCallbackHelper::findCallback(const char* name) const {
1525 wxPyCallbackHelper* self = (wxPyCallbackHelper*)this; // cast away const
1526 self->m_lastFound = NULL;
1527
1528 // If the object (m_self) has an attibute of the given name...
1529 if (m_self && PyObject_HasAttrString(m_self, (char*)name)) {
1530 PyObject *method, *klass;
1531 method = PyObject_GetAttrString(m_self, (char*)name);
1532
1533 // ...and if that attribute is a method, and if that method's class is
1534 // not from a base class...
1535 if (PyMethod_Check(method) &&
1536 (klass = PyMethod_GetDefiningClass(method, (char*)name)) != NULL &&
1537 ((klass == m_class) || PyObject_IsSubclass(klass, m_class))) {
1538
1539 // ...then we'll save a pointer to the method so callCallback can call it.
1540 self->m_lastFound = method;
1541 }
1542 else {
1543 Py_DECREF(method);
1544 }
1545 }
1546 return m_lastFound != NULL;
1547 }
1548
1549
1550 int wxPyCallbackHelper::callCallback(PyObject* argTuple) const {
1551 PyObject* result;
1552 int retval = False;
1553
1554 result = callCallbackObj(argTuple);
1555 if (result) { // Assumes an integer return type...
1556 retval = PyInt_AsLong(result);
1557 Py_DECREF(result);
1558 PyErr_Clear(); // forget about it if it's not...
1559 }
1560 return retval;
1561 }
1562
1563 // Invoke the Python callable object, returning the raw PyObject return
1564 // value. Caller should DECREF the return value and also manage the GIL.
1565 PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const {
1566 PyObject* result;
1567
1568 // Save a copy of the pointer in case the callback generates another
1569 // callback. In that case m_lastFound will have a different value when
1570 // it gets back here...
1571 PyObject* method = m_lastFound;
1572
1573 result = PyEval_CallObject(method, argTuple);
1574 Py_DECREF(argTuple);
1575 Py_DECREF(method);
1576 if (!result) {
1577 PyErr_Print();
1578 }
1579 return result;
1580 }
1581
1582
1583 void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref) {
1584 cbh.setSelf(self, klass, incref);
1585 }
1586
1587 bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name) {
1588 return cbh.findCallback(name);
1589 }
1590
1591 int wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple) {
1592 return cbh.callCallback(argTuple);
1593 }
1594
1595 PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple) {
1596 return cbh.callCallbackObj(argTuple);
1597 }
1598
1599
1600 void wxPyCBH_delete(wxPyCallbackHelper* cbh) {
1601 if (cbh->m_incRef) {
1602 wxPyBeginBlockThreads();
1603 Py_XDECREF(cbh->m_self);
1604 Py_XDECREF(cbh->m_class);
1605 wxPyEndBlockThreads();
1606 }
1607 }
1608
1609 //---------------------------------------------------------------------------
1610 //---------------------------------------------------------------------------
1611 // These event classes can be derived from in Python and passed through the event
1612 // system without losing anything. They do this by keeping a reference to
1613 // themselves and some special case handling in wxPyCallback::EventThunker.
1614
1615
1616 wxPyEvtSelfRef::wxPyEvtSelfRef() {
1617 //m_self = Py_None; // **** We don't do normal ref counting to prevent
1618 //Py_INCREF(m_self); // circular loops...
1619 m_cloned = False;
1620 }
1621
1622 wxPyEvtSelfRef::~wxPyEvtSelfRef() {
1623 wxPyBeginBlockThreads();
1624 if (m_cloned)
1625 Py_DECREF(m_self);
1626 wxPyEndBlockThreads();
1627 }
1628
1629 void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) {
1630 wxPyBeginBlockThreads();
1631 if (m_cloned)
1632 Py_DECREF(m_self);
1633 m_self = self;
1634 if (clone) {
1635 Py_INCREF(m_self);
1636 m_cloned = True;
1637 }
1638 wxPyEndBlockThreads();
1639 }
1640
1641 PyObject* wxPyEvtSelfRef::GetSelf() const {
1642 Py_INCREF(m_self);
1643 return m_self;
1644 }
1645
1646
1647 IMPLEMENT_ABSTRACT_CLASS(wxPyEvent, wxEvent);
1648 IMPLEMENT_ABSTRACT_CLASS(wxPyCommandEvent, wxCommandEvent);
1649
1650
1651 wxPyEvent::wxPyEvent(int winid, wxEventType commandType)
1652 : wxEvent(winid, commandType) {
1653 }
1654
1655
1656 wxPyEvent::wxPyEvent(const wxPyEvent& evt)
1657 : wxEvent(evt)
1658 {
1659 SetSelf(evt.m_self, True);
1660 }
1661
1662
1663 wxPyEvent::~wxPyEvent() {
1664 }
1665
1666
1667 wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id)
1668 : wxCommandEvent(commandType, id) {
1669 }
1670
1671
1672 wxPyCommandEvent::wxPyCommandEvent(const wxPyCommandEvent& evt)
1673 : wxCommandEvent(evt)
1674 {
1675 SetSelf(evt.m_self, True);
1676 }
1677
1678
1679 wxPyCommandEvent::~wxPyCommandEvent() {
1680 }
1681
1682
1683
1684
1685
1686 //---------------------------------------------------------------------------
1687 //---------------------------------------------------------------------------
1688 // Convert a wxList to a Python List, only works for lists of wxObjects
1689
1690 PyObject* wxPy_ConvertList(wxListBase* listbase) {
1691 wxList* list = (wxList*)listbase; // this is probably bad...
1692 PyObject* pyList;
1693 PyObject* pyObj;
1694 wxObject* wxObj;
1695 wxNode* node = list->GetFirst();
1696
1697 wxPyBeginBlockThreads();
1698 pyList = PyList_New(0);
1699 while (node) {
1700 wxObj = node->GetData();
1701 pyObj = wxPyMake_wxObject(wxObj);
1702 PyList_Append(pyList, pyObj);
1703 node = node->GetNext();
1704 }
1705 wxPyEndBlockThreads();
1706 return pyList;
1707 }
1708
1709 //----------------------------------------------------------------------
1710
1711 long wxPyGetWinHandle(wxWindow* win) {
1712
1713 #ifdef __WXMSW__
1714 return (long)win->GetHandle();
1715 #endif
1716
1717 // Find and return the actual X-Window.
1718 #ifdef __WXGTK__
1719 if (win->m_wxwindow) {
1720 #ifdef __WXGTK20__
1721 return (long) GDK_WINDOW_XWINDOW(GTK_PIZZA(win->m_wxwindow)->bin_window);
1722 #else
1723 GdkWindowPrivate* bwin = (GdkWindowPrivate*)GTK_PIZZA(win->m_wxwindow)->bin_window;
1724 if (bwin) {
1725 return (long)bwin->xwindow;
1726 }
1727 #endif
1728 }
1729 #endif
1730
1731 #ifdef __WXMAC__
1732 return (long)MAC_WXHWND(win->MacGetRootWindow());
1733 #endif
1734
1735 return 0;
1736 }
1737
1738 //----------------------------------------------------------------------
1739 // Some helper functions for typemaps in my_typemaps.i, so they won't be
1740 // included in every file over and over again...
1741
1742 #if PYTHON_API_VERSION >= 1009
1743 static char* wxStringErrorMsg = "String or Unicode type required";
1744 #else
1745 static char* wxStringErrorMsg = "String type required";
1746 #endif
1747
1748
1749 wxString* wxString_in_helper(PyObject* source) {
1750 wxString* target;
1751 #if PYTHON_API_VERSION >= 1009 // Have Python unicode API
1752 if (!PyString_Check(source) && !PyUnicode_Check(source)) {
1753 PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1754 return NULL;
1755 }
1756 #if wxUSE_UNICODE
1757 if (PyUnicode_Check(source)) {
1758 target = new wxString();
1759 size_t len = PyUnicode_GET_SIZE(source);
1760 if (len) {
1761 PyUnicode_AsWideChar((PyUnicodeObject*)source, target->GetWriteBuf(len), len);
1762 target->UngetWriteBuf();
1763 }
1764 } else {
1765 // It is a string, get pointers to it and transform to unicode
1766 char* tmpPtr; int tmpSize;
1767 PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
1768 target = new wxString(tmpPtr, *wxConvCurrent, tmpSize);
1769 }
1770 #else
1771 char* tmpPtr; int tmpSize;
1772 if (PyString_AsStringAndSize(source, &tmpPtr, &tmpSize) == -1) {
1773 PyErr_SetString(PyExc_TypeError, "Unable to convert string");
1774 return NULL;
1775 }
1776 target = new wxString(tmpPtr, tmpSize);
1777 #endif // wxUSE_UNICODE
1778
1779 #else // No Python unicode API (1.5.2)
1780 if (!PyString_Check(source)) {
1781 PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1782 return NULL;
1783 }
1784 target = new wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source));
1785 #endif
1786 return target;
1787 }
1788
1789
1790 // Similar to above except doesn't use "new" and doesn't set an exception
1791 wxString Py2wxString(PyObject* source)
1792 {
1793 wxString target;
1794 bool doDecRef = False;
1795
1796 #if PYTHON_API_VERSION >= 1009 // Have Python unicode API
1797 if (!PyString_Check(source) && !PyUnicode_Check(source)) {
1798 // Convert to String if not one already... (TODO: Unicode too?)
1799 source = PyObject_Str(source);
1800 doDecRef = True;
1801 }
1802
1803 #if wxUSE_UNICODE
1804 if (PyUnicode_Check(source)) {
1805 size_t len = PyUnicode_GET_SIZE(source);
1806 if (len) {
1807 PyUnicode_AsWideChar((PyUnicodeObject*)source, target.GetWriteBuf(len), len);
1808 target.UngetWriteBuf();
1809 }
1810 } else {
1811 // It is a string, get pointers to it and transform to unicode
1812 char* tmpPtr; int tmpSize;
1813 PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
1814 target = wxString(tmpPtr, *wxConvCurrent, tmpSize);
1815 }
1816 #else
1817 char* tmpPtr; int tmpSize;
1818 PyString_AsStringAndSize(source, &tmpPtr, &tmpSize);
1819 target = wxString(tmpPtr, tmpSize);
1820 #endif // wxUSE_UNICODE
1821
1822 #else // No Python unicode API (1.5.2)
1823 if (!PyString_Check(source)) {
1824 // Convert to String if not one already...
1825 source = PyObject_Str(source);
1826 doDecRef = True;
1827 }
1828 target = wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source));
1829 #endif
1830
1831 if (doDecRef)
1832 Py_DECREF(source);
1833 return target;
1834 }
1835
1836
1837 // Make either a Python String or Unicode object, depending on build mode
1838 PyObject* wx2PyString(const wxString& src)
1839 {
1840 PyObject* str;
1841 #if wxUSE_UNICODE
1842 str = PyUnicode_FromWideChar(src.c_str(), src.Len());
1843 #else
1844 str = PyString_FromStringAndSize(src.c_str(), src.Len());
1845 #endif
1846 return str;
1847 }
1848
1849
1850 //----------------------------------------------------------------------
1851
1852
1853 byte* byte_LIST_helper(PyObject* source) {
1854 if (!PyList_Check(source)) {
1855 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1856 return NULL;
1857 }
1858 int count = PyList_Size(source);
1859 byte* temp = new byte[count];
1860 if (! temp) {
1861 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1862 return NULL;
1863 }
1864 for (int x=0; x<count; x++) {
1865 PyObject* o = PyList_GetItem(source, x);
1866 if (! PyInt_Check(o)) {
1867 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
1868 return NULL;
1869 }
1870 temp[x] = (byte)PyInt_AsLong(o);
1871 }
1872 return temp;
1873 }
1874
1875
1876 int* int_LIST_helper(PyObject* source) {
1877 if (!PyList_Check(source)) {
1878 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1879 return NULL;
1880 }
1881 int count = PyList_Size(source);
1882 int* temp = new int[count];
1883 if (! temp) {
1884 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1885 return NULL;
1886 }
1887 for (int x=0; x<count; x++) {
1888 PyObject* o = PyList_GetItem(source, x);
1889 if (! PyInt_Check(o)) {
1890 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
1891 return NULL;
1892 }
1893 temp[x] = PyInt_AsLong(o);
1894 }
1895 return temp;
1896 }
1897
1898
1899 long* long_LIST_helper(PyObject* source) {
1900 if (!PyList_Check(source)) {
1901 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1902 return NULL;
1903 }
1904 int count = PyList_Size(source);
1905 long* temp = new long[count];
1906 if (! temp) {
1907 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1908 return NULL;
1909 }
1910 for (int x=0; x<count; x++) {
1911 PyObject* o = PyList_GetItem(source, x);
1912 if (! PyInt_Check(o)) {
1913 PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
1914 return NULL;
1915 }
1916 temp[x] = PyInt_AsLong(o);
1917 }
1918 return temp;
1919 }
1920
1921
1922 char** string_LIST_helper(PyObject* source) {
1923 if (!PyList_Check(source)) {
1924 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
1925 return NULL;
1926 }
1927 int count = PyList_Size(source);
1928 char** temp = new char*[count];
1929 if (! temp) {
1930 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1931 return NULL;
1932 }
1933 for (int x=0; x<count; x++) {
1934 PyObject* o = PyList_GetItem(source, x);
1935 if (! PyString_Check(o)) {
1936 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1937 return NULL;
1938 }
1939 temp[x] = PyString_AsString(o);
1940 }
1941 return temp;
1942 }
1943
1944 //--------------------------------
1945 // Part of patch from Tim Hochberg
1946 static inline bool wxPointFromObjects(PyObject* o1, PyObject* o2, wxPoint* point) {
1947 if (PyInt_Check(o1) && PyInt_Check(o2)) {
1948 point->x = PyInt_AS_LONG(o1);
1949 point->y = PyInt_AS_LONG(o2);
1950 return True;
1951 }
1952 if (PyFloat_Check(o1) && PyFloat_Check(o2)) {
1953 point->x = (int)PyFloat_AS_DOUBLE(o1);
1954 point->y = (int)PyFloat_AS_DOUBLE(o2);
1955 return True;
1956 }
1957 if (wxPySwigInstance_Check(o1) || wxPySwigInstance_Check(o2)) { // TODO: Why???
1958 // Disallow instances because they can cause havok
1959 return False;
1960 }
1961 if (PyNumber_Check(o1) && PyNumber_Check(o2)) {
1962 // I believe this excludes instances, so this should be safe without INCREFFing o1 and o2
1963 point->x = PyInt_AsLong(o1);
1964 point->y = PyInt_AsLong(o2);
1965 return True;
1966 }
1967 return False;
1968 }
1969
1970
1971 wxPoint* wxPoint_LIST_helper(PyObject* source, int *count) {
1972 // Putting all of the declarations here allows
1973 // us to put the error handling all in one place.
1974 int x;
1975 wxPoint* temp;
1976 PyObject *o, *o1, *o2;
1977 bool isFast = PyList_Check(source) || PyTuple_Check(source);
1978
1979 if (!PySequence_Check(source)) {
1980 goto error0;
1981 }
1982
1983 // The length of the sequence is returned in count.
1984 *count = PySequence_Length(source);
1985 if (*count < 0) {
1986 goto error0;
1987 }
1988
1989 temp = new wxPoint[*count];
1990 if (!temp) {
1991 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
1992 return NULL;
1993 }
1994 for (x=0; x<*count; x++) {
1995 // Get an item: try fast way first.
1996 if (isFast) {
1997 o = PySequence_Fast_GET_ITEM(source, x);
1998 }
1999 else {
2000 o = PySequence_GetItem(source, x);
2001 if (o == NULL) {
2002 goto error1;
2003 }
2004 }
2005
2006 // Convert o to wxPoint.
2007 if ((PyTuple_Check(o) && PyTuple_GET_SIZE(o) == 2) ||
2008 (PyList_Check(o) && PyList_GET_SIZE(o) == 2)) {
2009 o1 = PySequence_Fast_GET_ITEM(o, 0);
2010 o2 = PySequence_Fast_GET_ITEM(o, 1);
2011 if (!wxPointFromObjects(o1, o2, &temp[x])) {
2012 goto error2;
2013 }
2014 }
2015 else if (wxPySwigInstance_Check(o)) {
2016 wxPoint* pt;
2017 if (! wxPyConvertSwigPtr(o, (void **)&pt, wxT("wxPoint"))) {
2018 goto error2;
2019 }
2020 temp[x] = *pt;
2021 }
2022 else if (PySequence_Check(o) && PySequence_Length(o) == 2) {
2023 o1 = PySequence_GetItem(o, 0);
2024 o2 = PySequence_GetItem(o, 1);
2025 if (!wxPointFromObjects(o1, o2, &temp[x])) {
2026 goto error3;
2027 }
2028 Py_DECREF(o1);
2029 Py_DECREF(o2);
2030 }
2031 else {
2032 goto error2;
2033 }
2034 // Clean up.
2035 if (!isFast)
2036 Py_DECREF(o);
2037 }
2038 return temp;
2039
2040 error3:
2041 Py_DECREF(o1);
2042 Py_DECREF(o2);
2043 error2:
2044 if (!isFast)
2045 Py_DECREF(o);
2046 error1:
2047 delete [] temp;
2048 error0:
2049 PyErr_SetString(PyExc_TypeError, "Expected a sequence of length-2 sequences or wxPoints.");
2050 return NULL;
2051 }
2052 // end of patch
2053 //------------------------------
2054
2055
2056 wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
2057 if (!PyList_Check(source)) {
2058 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2059 return NULL;
2060 }
2061 int count = PyList_Size(source);
2062 wxBitmap** temp = new wxBitmap*[count];
2063 if (! temp) {
2064 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2065 return NULL;
2066 }
2067 for (int x=0; x<count; x++) {
2068 PyObject* o = PyList_GetItem(source, x);
2069 if (wxPySwigInstance_Check(o)) {
2070 wxBitmap* pt;
2071 if (! wxPyConvertSwigPtr(o, (void **) &pt, wxT("wxBitmap"))) {
2072 PyErr_SetString(PyExc_TypeError,"Expected wxBitmap.");
2073 return NULL;
2074 }
2075 temp[x] = pt;
2076 }
2077 else {
2078 PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
2079 return NULL;
2080 }
2081 }
2082 return temp;
2083 }
2084
2085
2086
2087 wxString* wxString_LIST_helper(PyObject* source) {
2088 if (!PyList_Check(source)) {
2089 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2090 return NULL;
2091 }
2092 int count = PyList_Size(source);
2093 wxString* temp = new wxString[count];
2094 if (! temp) {
2095 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2096 return NULL;
2097 }
2098 for (int x=0; x<count; x++) {
2099 PyObject* o = PyList_GetItem(source, x);
2100 #if PYTHON_API_VERSION >= 1009
2101 if (! PyString_Check(o) && ! PyUnicode_Check(o)) {
2102 PyErr_SetString(PyExc_TypeError, "Expected a list of string or unicode objects.");
2103 return NULL;
2104 }
2105 #else
2106 if (! PyString_Check(o)) {
2107 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
2108 return NULL;
2109 }
2110 #endif
2111
2112 wxString* pStr = wxString_in_helper(o);
2113 temp[x] = *pStr;
2114 delete pStr;
2115 }
2116 return temp;
2117 }
2118
2119
2120 wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
2121 if (!PyList_Check(source)) {
2122 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2123 return NULL;
2124 }
2125 int count = PyList_Size(source);
2126 wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
2127 if (! temp) {
2128 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2129 return NULL;
2130 }
2131 for (int x=0; x<count; x++) {
2132 PyObject* o = PyList_GetItem(source, x);
2133 if (wxPySwigInstance_Check(o)) {
2134 wxAcceleratorEntry* ae;
2135 if (! wxPyConvertSwigPtr(o, (void **) &ae, wxT("wxAcceleratorEntry"))) {
2136 PyErr_SetString(PyExc_TypeError,"Expected wxAcceleratorEntry.");
2137 return NULL;
2138 }
2139 temp[x] = *ae;
2140 }
2141 else if (PyTuple_Check(o)) {
2142 PyObject* o1 = PyTuple_GetItem(o, 0);
2143 PyObject* o2 = PyTuple_GetItem(o, 1);
2144 PyObject* o3 = PyTuple_GetItem(o, 2);
2145 temp[x].Set(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3));
2146 }
2147 else {
2148 PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
2149 return NULL;
2150 }
2151 }
2152 return temp;
2153 }
2154
2155
2156 wxPen** wxPen_LIST_helper(PyObject* source) {
2157 if (!PyList_Check(source)) {
2158 PyErr_SetString(PyExc_TypeError, "Expected a list object.");
2159 return NULL;
2160 }
2161 int count = PyList_Size(source);
2162 wxPen** temp = new wxPen*[count];
2163 if (!temp) {
2164 PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
2165 return NULL;
2166 }
2167 for (int x=0; x<count; x++) {
2168 PyObject* o = PyList_GetItem(source, x);
2169 if (wxPySwigInstance_Check(o)) {
2170 wxPen* pt;
2171 if (! wxPyConvertSwigPtr(o, (void **)&pt, wxT("wxPen"))) {
2172 delete temp;
2173 PyErr_SetString(PyExc_TypeError,"Expected wxPen.");
2174 return NULL;
2175 }
2176 temp[x] = pt;
2177 }
2178 else {
2179 delete temp;
2180 PyErr_SetString(PyExc_TypeError, "Expected a list of wxPens.");
2181 return NULL;
2182 }
2183 }
2184 return temp;
2185 }
2186
2187
2188 bool wxPy2int_seq_helper(PyObject* source, int* i1, int* i2) {
2189 bool isFast = PyList_Check(source) || PyTuple_Check(source);
2190 PyObject *o1, *o2;
2191
2192 if (!PySequence_Check(source) || PySequence_Length(source) != 2)
2193 return False;
2194
2195 if (isFast) {
2196 o1 = PySequence_Fast_GET_ITEM(source, 0);
2197 o2 = PySequence_Fast_GET_ITEM(source, 1);
2198 }
2199 else {
2200 o1 = PySequence_GetItem(source, 0);
2201 o2 = PySequence_GetItem(source, 1);
2202 }
2203
2204 *i1 = PyInt_AsLong(o1);
2205 *i2 = PyInt_AsLong(o2);
2206
2207 if (! isFast) {
2208 Py_DECREF(o1);
2209 Py_DECREF(o2);
2210 }
2211 return True;
2212 }
2213
2214
2215 bool wxPy4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4) {
2216 bool isFast = PyList_Check(source) || PyTuple_Check(source);
2217 PyObject *o1, *o2, *o3, *o4;
2218
2219 if (!PySequence_Check(source) || PySequence_Length(source) != 4)
2220 return False;
2221
2222 if (isFast) {
2223 o1 = PySequence_Fast_GET_ITEM(source, 0);
2224 o2 = PySequence_Fast_GET_ITEM(source, 1);
2225 o3 = PySequence_Fast_GET_ITEM(source, 2);
2226 o4 = PySequence_Fast_GET_ITEM(source, 3);
2227 }
2228 else {
2229 o1 = PySequence_GetItem(source, 0);
2230 o2 = PySequence_GetItem(source, 1);
2231 o3 = PySequence_GetItem(source, 2);
2232 o4 = PySequence_GetItem(source, 3);
2233 }
2234
2235 *i1 = PyInt_AsLong(o1);
2236 *i2 = PyInt_AsLong(o2);
2237 *i3 = PyInt_AsLong(o3);
2238 *i4 = PyInt_AsLong(o4);
2239
2240 if (! isFast) {
2241 Py_DECREF(o1);
2242 Py_DECREF(o2);
2243 Py_DECREF(o3);
2244 Py_DECREF(o4);
2245 }
2246 return True;
2247 }
2248
2249
2250 //----------------------------------------------------------------------
2251
2252 bool wxPySimple_typecheck(PyObject* source, const wxChar* classname, int seqLen)
2253 {
2254 void* ptr;
2255
2256 if (wxPySwigInstance_Check(source) &&
2257 wxPyConvertSwigPtr(source, (void **)&ptr, classname))
2258 return True;
2259
2260 PyErr_Clear();
2261 if (PySequence_Check(source) && PySequence_Length(source) == seqLen)
2262 return True;
2263
2264 return False;
2265 }
2266
2267 bool wxSize_helper(PyObject* source, wxSize** obj)
2268 {
2269 if (source == Py_None) {
2270 **obj = wxSize(-1,-1);
2271 return True;
2272 }
2273 return wxPyTwoIntItem_helper(source, obj, wxT("wxSize"));
2274 }
2275
2276
2277 bool wxPoint_helper(PyObject* source, wxPoint** obj)
2278 {
2279 if (source == Py_None) {
2280 **obj = wxPoint(-1,-1);
2281 return True;
2282 }
2283 return wxPyTwoIntItem_helper(source, obj, wxT("wxPoint"));
2284 }
2285
2286
2287
2288 bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
2289
2290 if (source == Py_None) {
2291 **obj = wxRealPoint(-1,-1);
2292 return True;
2293 }
2294
2295 // If source is an object instance then it may already be the right type
2296 if (wxPySwigInstance_Check(source)) {
2297 wxRealPoint* ptr;
2298 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxRealPoint")))
2299 goto error;
2300 *obj = ptr;
2301 return True;
2302 }
2303 // otherwise a 2-tuple of floats is expected
2304 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
2305 PyObject* o1 = PySequence_GetItem(source, 0);
2306 PyObject* o2 = PySequence_GetItem(source, 1);
2307 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2308 Py_DECREF(o1);
2309 Py_DECREF(o2);
2310 goto error;
2311 }
2312 **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
2313 Py_DECREF(o1);
2314 Py_DECREF(o2);
2315 return True;
2316 }
2317
2318 error:
2319 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object.");
2320 return False;
2321 }
2322
2323
2324
2325 bool wxRect_helper(PyObject* source, wxRect** obj) {
2326
2327 if (source == Py_None) {
2328 **obj = wxRect(-1,-1,-1,-1);
2329 return True;
2330 }
2331
2332 // If source is an object instance then it may already be the right type
2333 if (wxPySwigInstance_Check(source)) {
2334 wxRect* ptr;
2335 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxRect")))
2336 goto error;
2337 *obj = ptr;
2338 return True;
2339 }
2340 // otherwise a 4-tuple of integers is expected
2341 else if (PySequence_Check(source) && PyObject_Length(source) == 4) {
2342 PyObject* o1 = PySequence_GetItem(source, 0);
2343 PyObject* o2 = PySequence_GetItem(source, 1);
2344 PyObject* o3 = PySequence_GetItem(source, 2);
2345 PyObject* o4 = PySequence_GetItem(source, 3);
2346 if (!PyNumber_Check(o1) || !PyNumber_Check(o2) ||
2347 !PyNumber_Check(o3) || !PyNumber_Check(o4)) {
2348 Py_DECREF(o1);
2349 Py_DECREF(o2);
2350 Py_DECREF(o3);
2351 Py_DECREF(o4);
2352 goto error;
2353 }
2354 **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),
2355 PyInt_AsLong(o3), PyInt_AsLong(o4));
2356 Py_DECREF(o1);
2357 Py_DECREF(o2);
2358 Py_DECREF(o3);
2359 Py_DECREF(o4);
2360 return True;
2361 }
2362
2363 error:
2364 PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object.");
2365 return False;
2366 }
2367
2368
2369
2370 bool wxColour_helper(PyObject* source, wxColour** obj) {
2371
2372 if (source == Py_None) {
2373 **obj = wxNullColour;
2374 return True;
2375 }
2376
2377 // If source is an object instance then it may already be the right type
2378 if (wxPySwigInstance_Check(source)) {
2379 wxColour* ptr;
2380 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxColour")))
2381 goto error;
2382 *obj = ptr;
2383 return True;
2384 }
2385 // otherwise check for a string
2386 else if (PyString_Check(source) || PyUnicode_Check(source)) {
2387 wxString spec = Py2wxString(source);
2388 if (spec.GetChar(0) == '#' && spec.Length() == 7) { // It's #RRGGBB
2389 long red, green, blue;
2390 red = green = blue = 0;
2391 spec.Mid(1,2).ToLong(&red, 16);
2392 spec.Mid(3,2).ToLong(&green, 16);
2393 spec.Mid(5,2).ToLong(&blue, 16);
2394
2395 **obj = wxColour(red, green, blue);
2396 return True;
2397 }
2398 else { // it's a colour name
2399 **obj = wxColour(spec);
2400 return True;
2401 }
2402 }
2403 // last chance: 3-tuple of integers is expected
2404 else if (PySequence_Check(source) && PyObject_Length(source) == 3) {
2405 PyObject* o1 = PySequence_GetItem(source, 0);
2406 PyObject* o2 = PySequence_GetItem(source, 1);
2407 PyObject* o3 = PySequence_GetItem(source, 2);
2408 if (!PyNumber_Check(o1) || !PyNumber_Check(o2) || !PyNumber_Check(o3)) {
2409 Py_DECREF(o1);
2410 Py_DECREF(o2);
2411 Py_DECREF(o3);
2412 goto error;
2413 }
2414 **obj = wxColour(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3));
2415 Py_DECREF(o1);
2416 Py_DECREF(o2);
2417 Py_DECREF(o3);
2418 return True;
2419 }
2420
2421 error:
2422 PyErr_SetString(PyExc_TypeError,
2423 "Expected a wxColour object or a string containing a colour name or '#RRGGBB'.");
2424 return False;
2425 }
2426
2427
2428 bool wxColour_typecheck(PyObject* source) {
2429
2430 if (wxPySimple_typecheck(source, wxT("wxColour"), 3))
2431 return True;
2432
2433 if (PyString_Check(source) || PyUnicode_Check(source))
2434 return True;
2435
2436 return False;
2437 }
2438
2439
2440
2441 bool wxPoint2D_helper(PyObject* source, wxPoint2D** obj) {
2442
2443 if (source == Py_None) {
2444 **obj = wxPoint2D(-1,-1);
2445 return True;
2446 }
2447
2448 // If source is an object instance then it may already be the right type
2449 if (wxPySwigInstance_Check(source)) {
2450 wxPoint2D* ptr;
2451 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxPoint2D")))
2452 goto error;
2453 *obj = ptr;
2454 return True;
2455 }
2456 // otherwise a length-2 sequence of floats is expected
2457 if (PySequence_Check(source) && PySequence_Length(source) == 2) {
2458 PyObject* o1 = PySequence_GetItem(source, 0);
2459 PyObject* o2 = PySequence_GetItem(source, 1);
2460 // This should really check for floats, not numbers -- but that would break code.
2461 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
2462 Py_DECREF(o1);
2463 Py_DECREF(o2);
2464 goto error;
2465 }
2466 **obj = wxPoint2D(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
2467 Py_DECREF(o1);
2468 Py_DECREF(o2);
2469 return True;
2470 }
2471 error:
2472 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxPoint2D object.");
2473 return False;
2474 }
2475
2476
2477 //----------------------------------------------------------------------
2478
2479 PyObject* wxArrayString2PyList_helper(const wxArrayString& arr) {
2480
2481 PyObject* list = PyList_New(0);
2482 for (size_t i=0; i < arr.GetCount(); i++) {
2483 #if wxUSE_UNICODE
2484 PyObject* str = PyUnicode_FromWideChar(arr[i].c_str(), arr[i].Len());
2485 #else
2486 PyObject* str = PyString_FromStringAndSize(arr[i].c_str(), arr[i].Len());
2487 #endif
2488 PyList_Append(list, str);
2489 Py_DECREF(str);
2490 }
2491 return list;
2492 }
2493
2494
2495 PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr) {
2496
2497 PyObject* list = PyList_New(0);
2498 for (size_t i=0; i < arr.GetCount(); i++) {
2499 PyObject* number = PyInt_FromLong(arr[i]);
2500 PyList_Append(list, number);
2501 Py_DECREF(number);
2502 }
2503 return list;
2504 }
2505
2506
2507 //----------------------------------------------------------------------
2508 //----------------------------------------------------------------------
2509
2510
2511
2512
wxWidgets (Impactor)