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