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