]>
git.saurik.com Git - wxWidgets.git/blob - wxPython/src/helpers.cpp
1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Helper functions/classes for the wxPython extension module
9 // Copyright: (c) 1998 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
17 #include "pyistream.h"
20 #include <wx/msw/private.h>
21 #include <wx/msw/winundef.h>
22 #include <wx/msw/msvcrt.h>
27 #include <gdk/gdkprivate.h>
28 #include <wx/gtk/win_gtk.h>
31 //----------------------------------------------------------------------
33 #if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE
34 #error Python must support Unicode to use wxWindows Unicode
37 //----------------------------------------------------------------------
40 int WXDLLEXPORT
wxEntryStart( int& argc
, char** argv
);
42 int WXDLLEXPORT
wxEntryStart( int argc
, char** argv
);
44 int WXDLLEXPORT
wxEntryInitGui();
45 void WXDLLEXPORT
wxEntryCleanup();
47 wxPyApp
* wxPythonApp
= NULL
; // Global instance of application object
48 bool wxPyDoCleanup
= FALSE
;
51 #ifdef WXP_WITH_THREAD
52 struct wxPyThreadState
{
54 PyThreadState
* tstate
;
56 wxPyThreadState(unsigned long _tid
=0, PyThreadState
* _tstate
=NULL
)
57 : tid(_tid
), tstate(_tstate
) {}
60 #include <wx/dynarray.h>
61 WX_DECLARE_OBJARRAY(wxPyThreadState
, wxPyThreadStateArray
);
62 #include <wx/arrimpl.cpp>
63 WX_DEFINE_OBJARRAY(wxPyThreadStateArray
);
65 wxPyThreadStateArray
* wxPyTStates
= NULL
;
66 wxMutex
* wxPyTMutex
= NULL
;
70 #ifdef __WXMSW__ // If building for win32...
71 //----------------------------------------------------------------------
72 // This gets run when the DLL is loaded. We just need to save a handle.
73 //----------------------------------------------------------------------
76 HINSTANCE hinstDLL
, // handle to DLL module
77 DWORD fdwReason
, // reason for calling function
78 LPVOID lpvReserved
// reserved
81 // If wxPython is embedded in another wxWindows app then
82 // the inatance has already been set.
83 if (! wxGetInstance())
84 wxSetInstance(hinstDLL
);
89 //----------------------------------------------------------------------
90 // Classes for implementing the wxp main application shell.
91 //----------------------------------------------------------------------
95 SetUseBestVisual(TRUE
);
102 // This one isn't acutally called... See __wxStart()
103 bool wxPyApp::OnInit() {
108 int wxPyApp::MainLoop() {
111 DeletePendingObjects();
112 bool initialized
= wxTopLevelWindows
.GetCount() != 0;
114 m_initialized
= initialized
;
118 if ( m_exitOnFrameDelete
== Later
) {
119 m_exitOnFrameDelete
= Yes
;
122 retval
= wxApp::MainLoop();
130 //---------------------------------------------------------------------
131 //----------------------------------------------------------------------
134 static char* wxPyCopyCString(const wxChar
* src
)
136 wxWX2MBbuf buff
= (wxWX2MBbuf
)wxConvCurrent
->cWX2MB(src
);
137 size_t len
= strlen(buff
);
138 char* dest
= new char[len
+1];
144 static char* wxPyCopyCString(const char* src
) // we need a char version too
146 size_t len
= strlen(src
);
147 char* dest
= new char[len
+1];
153 static wxChar
* wxPyCopyWString(const char *src
)
155 //wxMB2WXbuf buff = wxConvCurrent->cMB2WX(src);
156 wxString
str(src
, *wxConvCurrent
);
157 return copystring(str
);
161 static wxChar
* wxPyCopyWString(const wxChar
*src
)
163 return copystring(src
);
168 //----------------------------------------------------------------------
170 // This is where we pick up the first part of the wxEntry functionality...
171 // The rest is in __wxStart and __wxCleanup. This function is called when
172 // wxcmodule is imported. (Before there is a wxApp object.)
177 // wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
180 #ifdef WXP_WITH_THREAD
181 PyEval_InitThreads();
182 wxPyTStates
= new wxPyThreadStateArray
;
183 wxPyTMutex
= new wxMutex
;
186 wxApp::CheckBuildOptions(wxBuildOptions());
188 // Bail out if there is already a wxApp created. This means that the
189 // toolkit has already been initialized, as in embedding wxPython in
190 // a C++ wxWindows app, so we don't need to call wxEntryStart.
191 if (wxTheApp
!= NULL
) {
194 wxPyDoCleanup
= TRUE
;
198 PyObject
* sysargv
= PySys_GetObject("argv");
199 if (sysargv
!= NULL
) {
200 argc
= PyList_Size(sysargv
);
201 argv
= new char*[argc
+1];
203 for(x
=0; x
<argc
; x
++) {
204 PyObject
*item
= PyList_GetItem(sysargv
, x
);
206 if (PyUnicode_Check(item
))
207 argv
[x
] = wxPyCopyCString(PyUnicode_AS_UNICODE(item
));
210 argv
[x
] = wxPyCopyCString(PyString_AsString(item
));
215 wxEntryStart(argc
, argv
);
220 // Start the user application, user App's OnInit method is a parameter here
221 PyObject
* __wxStart(PyObject
* /* self */, PyObject
* args
)
223 PyObject
* onInitFunc
= NULL
;
228 if (!PyArg_ParseTuple(args
, "O", &onInitFunc
))
231 // This is the next part of the wxEntry functionality...
233 wxChar
** argv
= NULL
;
234 PyObject
* sysargv
= PySys_GetObject("argv");
235 if (sysargv
!= NULL
) {
236 argc
= PyList_Size(sysargv
);
237 argv
= new wxChar
*[argc
+1];
239 for(x
=0; x
<argc
; x
++) {
240 PyObject
*pyArg
= PyList_GetItem(sysargv
, x
);
242 if (PyUnicode_Check(pyArg
))
243 argv
[x
] = wxPyCopyWString(PyUnicode_AS_UNICODE(pyArg
));
246 argv
[x
] = wxPyCopyWString(PyString_AsString(pyArg
));
251 wxPythonApp
->argc
= argc
;
252 wxPythonApp
->argv
= argv
;
256 // Call the Python App's OnInit function
257 arglist
= PyTuple_New(0);
258 result
= PyEval_CallObject(onInitFunc
, arglist
);
259 if (!result
) { // an exception was raised.
263 if (! PyInt_Check(result
)) {
264 PyErr_SetString(PyExc_TypeError
, "OnInit should return a boolean value");
267 bResult
= PyInt_AS_LONG(result
);
269 PyErr_SetString(PyExc_SystemExit
, "OnInit returned FALSE, exiting...");
274 wxTheApp
->m_initialized
= (wxTopLevelWindows
.GetCount() > 0);
285 #ifdef WXP_WITH_THREAD
288 wxPyTStates
->Empty();
296 static PyObject
* wxPython_dict
= NULL
;
297 static PyObject
* wxPyPtrTypeMap
= NULL
;
300 PyObject
* __wxSetDictionary(PyObject
* /* self */, PyObject
* args
)
303 if (!PyArg_ParseTuple(args
, "O", &wxPython_dict
))
306 if (!PyDict_Check(wxPython_dict
)) {
307 PyErr_SetString(PyExc_TypeError
, "_wxSetDictionary must have dictionary object!");
311 if (! wxPyPtrTypeMap
)
312 wxPyPtrTypeMap
= PyDict_New();
313 PyDict_SetItemString(wxPython_dict
, "__wxPyPtrTypeMap", wxPyPtrTypeMap
);
317 #define wxPlatform "__WXMOTIF__"
320 #define wxPlatform "__WXX11__"
323 #define wxPlatform "__WXGTK__"
325 #if defined(__WIN32__) || defined(__WXMSW__)
326 #define wxPlatform "__WXMSW__"
329 #define wxPlatform "__WXMAC__"
338 PyDict_SetItemString(wxPython_dict
, "wxPlatform", PyString_FromString(wxPlatform
));
339 PyDict_SetItemString(wxPython_dict
, "wxUSE_UNICODE", PyInt_FromLong(wxUSE_UNICODE
));
340 PyDict_SetItemString(wxPython_dict
, "__WXDEBUG__", PyInt_FromLong(wxdebug
));
346 //---------------------------------------------------------------------------
348 void wxPyClientData_dtor(wxPyClientData
* self
) {
349 wxPyBeginBlockThreads();
350 Py_DECREF(self
->m_obj
);
351 wxPyEndBlockThreads();
354 void wxPyUserData_dtor(wxPyUserData
* self
) {
355 wxPyBeginBlockThreads();
356 Py_DECREF(self
->m_obj
);
357 wxPyEndBlockThreads();
361 // This is called when an OOR controled object is being destroyed. Although
362 // the C++ object is going away there is no way to force the Python object
363 // (and all references to it) to die too. This causes problems (crashes) in
364 // wxPython when a python shadow object attempts to call a C++ method using
365 // the now bogus pointer... So to try and prevent this we'll do a little black
366 // magic and change the class of the python instance to a class that will
367 // raise an exception for any attempt to call methods with it. See
368 // _wxPyDeadObject in _extras.py for the implementation of this class.
369 void wxPyOORClientData_dtor(wxPyOORClientData
* self
) {
371 static PyObject
* deadObjectClass
= NULL
;
373 wxPyBeginBlockThreads();
374 if (deadObjectClass
== NULL
) {
375 deadObjectClass
= PyDict_GetItemString(wxPython_dict
, "_wxPyDeadObject");
376 wxASSERT_MSG(deadObjectClass
!= NULL
, wxT("Can't get _wxPyDeadObject class!"));
377 Py_INCREF(deadObjectClass
);
380 // Clear the instance's dictionary, put the name of the old class into the
381 // instance, and then reset the class to be the dead class.
382 if (self
->m_obj
->ob_refcnt
> 1) { // but only if there is more than one reference
383 wxASSERT_MSG(PyInstance_Check(self
->m_obj
), wxT("m_obj not an instance!?!?!"));
384 PyInstanceObject
* inst
= (PyInstanceObject
*)self
->m_obj
;
385 PyDict_Clear(inst
->in_dict
);
386 PyDict_SetItemString(inst
->in_dict
, "_name", inst
->in_class
->cl_name
);
387 inst
->in_class
= (PyClassObject
*)deadObjectClass
;
388 Py_INCREF(deadObjectClass
);
390 wxPyEndBlockThreads();
393 //---------------------------------------------------------------------------
394 // Stuff used by OOR to find the right wxPython class type to return and to
398 // The pointer type map is used when the "pointer" type name generated by SWIG
399 // is not the same as the shadow class name, for example wxPyTreeCtrl
400 // vs. wxTreeCtrl. It needs to be referenced in Python as well as from C++,
401 // so we'll just make it a Python dictionary in the wx module's namespace.
402 // (See __wxSetDictionary)
403 void wxPyPtrTypeMap_Add(const char* commonName
, const char* ptrName
) {
404 if (! wxPyPtrTypeMap
)
405 wxPyPtrTypeMap
= PyDict_New();
406 PyDict_SetItemString(wxPyPtrTypeMap
,
408 PyString_FromString((char*)ptrName
));
413 PyObject
* wxPyClassExists(const wxString
& className
) {
418 char buff
[64]; // should always be big enough...
420 sprintf(buff
, "%sPtr", className
.mbc_str());
421 PyObject
* classobj
= PyDict_GetItemString(wxPython_dict
, buff
);
423 return classobj
; // returns NULL if not found
427 PyObject
* wxPyMake_wxObject(wxObject
* source
, bool checkEvtHandler
) {
428 PyObject
* target
= NULL
;
429 bool isEvtHandler
= FALSE
;
432 // If it's derived from wxEvtHandler then there may
433 // already be a pointer to a Python object that we can use
435 if (checkEvtHandler
&& wxIsKindOf(source
, wxEvtHandler
)) {
437 wxEvtHandler
* eh
= (wxEvtHandler
*)source
;
438 wxPyOORClientData
* data
= (wxPyOORClientData
*)eh
->GetClientObject();
440 target
= data
->m_obj
;
446 // Otherwise make it the old fashioned way by making a
447 // new shadow object and putting this pointer in it.
448 wxClassInfo
* info
= source
->GetClassInfo();
449 wxChar
* name
= (wxChar
*)info
->GetClassName();
450 PyObject
* klass
= wxPyClassExists(name
);
451 while (info
&& !klass
) {
452 name
= (wxChar
*)info
->GetBaseClassName1();
453 info
= wxClassInfo::FindClass(name
);
454 klass
= wxPyClassExists(name
);
457 target
= wxPyConstructObject(source
, name
, klass
, FALSE
);
458 if (target
&& isEvtHandler
)
459 ((wxEvtHandler
*)source
)->SetClientObject(new wxPyOORClientData(target
));
461 wxString
msg(wxT("wxPython class not found for "));
462 msg
+= source
->GetClassInfo()->GetClassName();
463 PyErr_SetString(PyExc_NameError
, msg
.mbc_str());
467 } else { // source was NULL so return None.
468 Py_INCREF(Py_None
); target
= Py_None
;
474 PyObject
* wxPyMake_wxSizer(wxSizer
* source
) {
475 PyObject
* target
= NULL
;
477 if (source
&& wxIsKindOf(source
, wxSizer
)) {
478 // If it's derived from wxSizer then there may
479 // already be a pointer to a Python object that we can use
481 wxSizer
* sz
= (wxSizer
*)source
;
482 wxPyOORClientData
* data
= (wxPyOORClientData
*)sz
->GetClientObject();
484 target
= data
->m_obj
;
489 target
= wxPyMake_wxObject(source
, FALSE
);
490 if (target
!= Py_None
)
491 ((wxSizer
*)source
)->SetClientObject(new wxPyOORClientData(target
));
498 //---------------------------------------------------------------------------
500 PyObject
* wxPyConstructObject(void* ptr
,
501 const wxString
& className
,
508 wxString
name(className
);
509 char swigptr
[64]; // should always be big enough...
512 if ((item
= PyDict_GetItemString(wxPyPtrTypeMap
, (char*)(const char*)name
.mbc_str())) != NULL
) {
513 name
= wxString(PyString_AsString(item
), *wxConvCurrent
);
515 sprintf(buff
, "_%s_p", (const char*)name
.mbc_str());
516 SWIG_MakePtr(swigptr
, ptr
, buff
);
518 arg
= Py_BuildValue("(s)", swigptr
);
519 obj
= PyInstance_New(klass
, arg
, NULL
);
523 PyObject
* one
= PyInt_FromLong(1);
524 PyObject_SetAttrString(obj
, "thisown", one
);
532 PyObject
* wxPyConstructObject(void* ptr
,
533 const wxString
& className
,
540 char buff
[64]; // should always be big enough...
541 sprintf(buff
, "%sPtr", (const char*)className
.mbc_str());
543 wxASSERT_MSG(wxPython_dict
, wxT("wxPython_dict is not set yet!!"));
545 PyObject
* classobj
= PyDict_GetItemString(wxPython_dict
, buff
);
547 wxString
msg(wxT("wxPython class not found for "));
549 PyErr_SetString(PyExc_NameError
, msg
.mbc_str());
553 return wxPyConstructObject(ptr
, className
, classobj
, setThisOwn
);
557 //---------------------------------------------------------------------------
560 #ifdef WXP_WITH_THREAD
562 unsigned long wxPyGetCurrentThreadId() {
563 return wxThread::GetCurrentId();
566 static PyThreadState
* gs_shutdownTState
;
568 PyThreadState
* wxPyGetThreadState() {
569 if (wxPyTMutex
== NULL
) // Python is shutting down...
570 return gs_shutdownTState
;
572 unsigned long ctid
= wxPyGetCurrentThreadId();
573 PyThreadState
* tstate
= NULL
;
576 for(size_t i
=0; i
< wxPyTStates
->GetCount(); i
++) {
577 wxPyThreadState
& info
= wxPyTStates
->Item(i
);
578 if (info
.tid
== ctid
) {
579 tstate
= info
.tstate
;
583 wxPyTMutex
->Unlock();
584 wxASSERT_MSG(tstate
, wxT("PyThreadState should not be NULL!"));
589 void wxPySaveThreadState(PyThreadState
* tstate
) {
590 if (wxPyTMutex
== NULL
) { // Python is shutting down, assume a single thread...
591 gs_shutdownTState
= tstate
;
594 unsigned long ctid
= wxPyGetCurrentThreadId();
596 for(size_t i
=0; i
< wxPyTStates
->GetCount(); i
++) {
597 wxPyThreadState
& info
= wxPyTStates
->Item(i
);
598 if (info
.tid
== ctid
) {
600 if (info
.tstate
!= tstate
)
601 wxLogMessage("*** tstate mismatch!???");
603 // info.tstate = tstate; *** DO NOT update existing ones???
604 // Normally it will never change, but apparently COM callbacks
605 // (i.e. ActiveX controls) will (incorrectly IMHO) use a transient
606 // tstate which will then be garbage the next time we try to use
608 wxPyTMutex
->Unlock();
612 // not found, so add it...
613 wxPyTStates
->Add(new wxPyThreadState(ctid
, tstate
));
614 wxPyTMutex
->Unlock();
620 // Calls from Python to wxWindows code are wrapped in calls to these
623 PyThreadState
* wxPyBeginAllowThreads() {
624 #ifdef WXP_WITH_THREAD
625 PyThreadState
* saved
= PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS;
626 wxPySaveThreadState(saved
);
633 void wxPyEndAllowThreads(PyThreadState
* saved
) {
634 #ifdef WXP_WITH_THREAD
635 PyEval_RestoreThread(saved
); // Py_END_ALLOW_THREADS;
641 // Calls from wxWindows back to Python code, or even any PyObject
642 // manipulations, PyDECREF's and etc. are wrapped in calls to these functions:
644 void wxPyBeginBlockThreads() {
645 #ifdef WXP_WITH_THREAD
646 PyThreadState
* tstate
= wxPyGetThreadState();
647 PyEval_RestoreThread(tstate
);
652 void wxPyEndBlockThreads() {
653 #ifdef WXP_WITH_THREAD
654 // Is there any need to save it again?
655 // PyThreadState* tstate =
661 //---------------------------------------------------------------------------
662 // wxPyInputStream and wxPyCBInputStream methods
665 void wxPyInputStream::close() {
666 /* do nothing for now */
669 void wxPyInputStream::flush() {
670 /* do nothing for now */
673 bool wxPyInputStream::eof() {
675 return m_wxis
->Eof();
680 wxPyInputStream::~wxPyInputStream() {
687 PyObject
* wxPyInputStream::read(int size
) {
688 PyObject
* obj
= NULL
;
690 const int BUFSIZE
= 1024;
692 // check if we have a real wxInputStream to work with
694 PyErr_SetString(PyExc_IOError
, "no valid C-wxInputStream");
700 while (! m_wxis
->Eof()) {
701 m_wxis
->Read(buf
.GetAppendBuf(BUFSIZE
), BUFSIZE
);
702 buf
.UngetAppendBuf(m_wxis
->LastRead());
705 } else { // Read only size number of characters
706 m_wxis
->Read(buf
.GetWriteBuf(size
), size
);
707 buf
.UngetWriteBuf(m_wxis
->LastRead());
711 if (m_wxis
->LastError() == wxSTREAM_READ_ERROR
) {
712 PyErr_SetString(PyExc_IOError
,"IOError in wxInputStream");
715 // We use only strings for the streams, not unicode
716 obj
= PyString_FromStringAndSize(buf
, buf
.GetDataLen());
722 PyObject
* wxPyInputStream::readline(int size
) {
723 PyObject
* obj
= NULL
;
728 // check if we have a real wxInputStream to work with
730 PyErr_SetString(PyExc_IOError
,"no valid C-wxInputStream");
734 // read until \n or byte limit reached
735 for (i
=ch
=0; (ch
!= '\n') && (!m_wxis
->Eof()) && ((size
< 0) || (i
< size
)); i
++) {
741 if (m_wxis
->LastError() == wxSTREAM_READ_ERROR
) {
742 PyErr_SetString(PyExc_IOError
,"IOError in wxInputStream");
745 // We use only strings for the streams, not unicode
746 obj
= PyString_FromStringAndSize((char*)buf
.GetData(), buf
.GetDataLen());
752 PyObject
* wxPyInputStream::readlines(int sizehint
) {
755 // check if we have a real wxInputStream to work with
757 PyErr_SetString(PyExc_IOError
,"no valid C-wxInputStream below");
762 pylist
= PyList_New(0);
768 // read sizehint bytes or until EOF
770 for (i
=0; (!m_wxis
->Eof()) && ((sizehint
< 0) || (i
< sizehint
));) {
771 PyObject
* s
= this->readline();
776 PyList_Append(pylist
, s
);
777 i
+= PyString_Size(s
);
781 if (m_wxis
->LastError() == wxSTREAM_READ_ERROR
) {
783 PyErr_SetString(PyExc_IOError
,"IOError in wxInputStream");
791 void wxPyInputStream::seek(int offset
, int whence
) {
793 m_wxis
->SeekI(offset
, wxSeekMode(whence
));
796 int wxPyInputStream::tell(){
798 return m_wxis
->TellI();
805 wxPyCBInputStream::wxPyCBInputStream(PyObject
*r
, PyObject
*s
, PyObject
*t
, bool block
)
806 : wxInputStream(), m_read(r
), m_seek(s
), m_tell(t
), m_block(block
)
810 wxPyCBInputStream::~wxPyCBInputStream() {
811 if (m_block
) wxPyBeginBlockThreads();
815 if (m_block
) wxPyEndBlockThreads();
819 wxPyCBInputStream
* wxPyCBInputStream::create(PyObject
*py
, bool block
) {
820 if (block
) wxPyBeginBlockThreads();
822 PyObject
* read
= getMethod(py
, "read");
823 PyObject
* seek
= getMethod(py
, "seek");
824 PyObject
* tell
= getMethod(py
, "tell");
827 PyErr_SetString(PyExc_TypeError
, "Not a file-like object");
831 if (block
) wxPyEndBlockThreads();
835 if (block
) wxPyEndBlockThreads();
836 return new wxPyCBInputStream(read
, seek
, tell
, block
);
840 wxPyCBInputStream
* wxPyCBInputStream_create(PyObject
*py
, bool block
) {
841 return wxPyCBInputStream::create(py
, block
);
844 PyObject
* wxPyCBInputStream::getMethod(PyObject
* py
, char* name
) {
845 if (!PyObject_HasAttrString(py
, name
))
847 PyObject
* o
= PyObject_GetAttrString(py
, name
);
848 if (!PyMethod_Check(o
) && !PyCFunction_Check(o
)) {
856 size_t wxPyCBInputStream::GetSize() const {
857 wxPyCBInputStream
* self
= (wxPyCBInputStream
*)this; // cast off const
858 if (m_seek
&& m_tell
) {
859 off_t temp
= self
->OnSysTell();
860 off_t ret
= self
->OnSysSeek(0, wxFromEnd
);
861 self
->OnSysSeek(temp
, wxFromStart
);
869 size_t wxPyCBInputStream::OnSysRead(void *buffer
, size_t bufsize
) {
873 wxPyBeginBlockThreads();
874 PyObject
* arglist
= Py_BuildValue("(i)", bufsize
);
875 PyObject
* result
= PyEval_CallObject(m_read
, arglist
);
879 if ((result
!= NULL
) && PyString_Check(result
)) {
880 o
= PyString_Size(result
);
882 m_lasterror
= wxSTREAM_EOF
;
885 memcpy((char*)buffer
, PyString_AsString(result
), o
); // strings only, not unicode...
890 m_lasterror
= wxSTREAM_READ_ERROR
;
891 wxPyEndBlockThreads();
896 size_t wxPyCBInputStream::OnSysWrite(const void *buffer
, size_t bufsize
) {
897 m_lasterror
= wxSTREAM_WRITE_ERROR
;
901 off_t
wxPyCBInputStream::OnSysSeek(off_t off
, wxSeekMode mode
) {
902 wxPyBeginBlockThreads();
903 PyObject
* arglist
= Py_BuildValue("(ii)", off
, mode
);
904 PyObject
* result
= PyEval_CallObject(m_seek
, arglist
);
907 wxPyEndBlockThreads();
911 off_t
wxPyCBInputStream::OnSysTell() const {
912 wxPyBeginBlockThreads();
913 PyObject
* arglist
= Py_BuildValue("()");
914 PyObject
* result
= PyEval_CallObject(m_tell
, arglist
);
917 if (result
!= NULL
) {
918 o
= PyInt_AsLong(result
);
921 wxPyEndBlockThreads();
925 //----------------------------------------------------------------------
927 IMPLEMENT_ABSTRACT_CLASS(wxPyCallback
, wxObject
);
929 wxPyCallback::wxPyCallback(PyObject
* func
) {
934 wxPyCallback::wxPyCallback(const wxPyCallback
& other
) {
935 m_func
= other
.m_func
;
939 wxPyCallback::~wxPyCallback() {
940 wxPyBeginBlockThreads();
942 wxPyEndBlockThreads();
947 // This function is used for all events destined for Python event handlers.
948 void wxPyCallback::EventThunker(wxEvent
& event
) {
949 wxPyCallback
* cb
= (wxPyCallback
*)event
.m_callbackUserData
;
950 PyObject
* func
= cb
->m_func
;
956 wxPyBeginBlockThreads();
957 wxString className
= event
.GetClassInfo()->GetClassName();
959 if (className
== "wxPyEvent")
960 arg
= ((wxPyEvent
*)&event
)->GetSelf();
961 else if (className
== "wxPyCommandEvent")
962 arg
= ((wxPyCommandEvent
*)&event
)->GetSelf();
964 arg
= wxPyConstructObject((void*)&event
, className
);
967 tuple
= PyTuple_New(1);
968 PyTuple_SET_ITEM(tuple
, 0, arg
);
969 result
= PyEval_CallObject(func
, tuple
);
973 PyErr_Clear(); // Just in case...
977 wxPyEndBlockThreads();
981 //----------------------------------------------------------------------
983 wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper
& other
) {
985 m_self
= other
.m_self
;
986 m_class
= other
.m_class
;
994 void wxPyCallbackHelper::setSelf(PyObject
* self
, PyObject
* klass
, int incref
) {
1005 #if PYTHON_API_VERSION >= 1011
1007 // Prior to Python 2.2 PyMethod_GetClass returned the class object
1008 // in which the method was defined. Starting with 2.2 it returns
1009 // "class that asked for the method" which seems totally bogus to me
1010 // but apprently it fixes some obscure problem waiting to happen in
1011 // Python. Since the API was not documented Guido and the gang felt
1012 // safe in changing it. Needless to say that totally screwed up the
1013 // logic below in wxPyCallbackHelper::findCallback, hence this icky
1014 // code to find the class where the method is actually defined...
1017 PyObject
* PyFindClassWithAttr(PyObject
*klass
, PyObject
*name
)
1021 if (PyType_Check(klass
)) { // new style classes
1022 // This code is borrowed/adapted from _PyType_Lookup in typeobject.c
1023 // (TODO: This part is not tested yet, so I'm not sure it is correct...)
1024 PyTypeObject
* type
= (PyTypeObject
*)klass
;
1025 PyObject
*mro
, *res
, *base
, *dict
;
1026 /* Look in tp_dict of types in MRO */
1028 assert(PyTuple_Check(mro
));
1029 n
= PyTuple_GET_SIZE(mro
);
1030 for (i
= 0; i
< n
; i
++) {
1031 base
= PyTuple_GET_ITEM(mro
, i
);
1032 if (PyClass_Check(base
))
1033 dict
= ((PyClassObject
*)base
)->cl_dict
;
1035 assert(PyType_Check(base
));
1036 dict
= ((PyTypeObject
*)base
)->tp_dict
;
1038 assert(dict
&& PyDict_Check(dict
));
1039 res
= PyDict_GetItem(dict
, name
);
1046 else if (PyClass_Check(klass
)) { // old style classes
1047 // This code is borrowed/adapted from class_lookup in classobject.c
1048 PyClassObject
* cp
= (PyClassObject
*)klass
;
1049 PyObject
*value
= PyDict_GetItem(cp
->cl_dict
, name
);
1050 if (value
!= NULL
) {
1051 return (PyObject
*)cp
;
1053 n
= PyTuple_Size(cp
->cl_bases
);
1054 for (i
= 0; i
< n
; i
++) {
1055 PyObject
* base
= PyTuple_GetItem(cp
->cl_bases
, i
);
1056 PyObject
*v
= PyFindClassWithAttr(base
, name
);
1068 PyObject
* PyMethod_GetDefiningClass(PyObject
* method
, const char* name
)
1070 PyObject
* mgc
= PyMethod_GET_CLASS(method
);
1072 #if PYTHON_API_VERSION <= 1010 // prior to Python 2.2, the easy way
1074 #else // 2.2 and after, the hard way...
1076 PyObject
* nameo
= PyString_FromString(name
);
1077 PyObject
* klass
= PyFindClassWithAttr(mgc
, nameo
);
1085 bool wxPyCallbackHelper::findCallback(const char* name
) const {
1086 wxPyCallbackHelper
* self
= (wxPyCallbackHelper
*)this; // cast away const
1087 self
->m_lastFound
= NULL
;
1089 // If the object (m_self) has an attibute of the given name...
1090 if (m_self
&& PyObject_HasAttrString(m_self
, (char*)name
)) {
1091 PyObject
*method
, *klass
;
1092 method
= PyObject_GetAttrString(m_self
, (char*)name
);
1094 // ...and if that attribute is a method, and if that method's class is
1095 // not from a base class...
1096 if (PyMethod_Check(method
) &&
1097 (klass
= PyMethod_GetDefiningClass(method
, (char*)name
)) != NULL
&&
1098 ((klass
== m_class
) || PyClass_IsSubclass(klass
, m_class
))) {
1100 // ...then we'll save a pointer to the method so callCallback can call it.
1101 self
->m_lastFound
= method
;
1107 return m_lastFound
!= NULL
;
1111 int wxPyCallbackHelper::callCallback(PyObject
* argTuple
) const {
1115 result
= callCallbackObj(argTuple
);
1116 if (result
) { // Assumes an integer return type...
1117 retval
= PyInt_AsLong(result
);
1119 PyErr_Clear(); // forget about it if it's not...
1124 // Invoke the Python callable object, returning the raw PyObject return
1125 // value. Caller should DECREF the return value and also call PyEval_SaveThread.
1126 PyObject
* wxPyCallbackHelper::callCallbackObj(PyObject
* argTuple
) const {
1129 // Save a copy of the pointer in case the callback generates another
1130 // callback. In that case m_lastFound will have a different value when
1131 // it gets back here...
1132 PyObject
* method
= m_lastFound
;
1134 result
= PyEval_CallObject(method
, argTuple
);
1135 Py_DECREF(argTuple
);
1144 void wxPyCBH_setCallbackInfo(wxPyCallbackHelper
& cbh
, PyObject
* self
, PyObject
* klass
, int incref
) {
1145 cbh
.setSelf(self
, klass
, incref
);
1148 bool wxPyCBH_findCallback(const wxPyCallbackHelper
& cbh
, const char* name
) {
1149 return cbh
.findCallback(name
);
1152 int wxPyCBH_callCallback(const wxPyCallbackHelper
& cbh
, PyObject
* argTuple
) {
1153 return cbh
.callCallback(argTuple
);
1156 PyObject
* wxPyCBH_callCallbackObj(const wxPyCallbackHelper
& cbh
, PyObject
* argTuple
) {
1157 return cbh
.callCallbackObj(argTuple
);
1161 void wxPyCBH_delete(wxPyCallbackHelper
* cbh
) {
1162 if (cbh
->m_incRef
) {
1163 wxPyBeginBlockThreads();
1164 Py_XDECREF(cbh
->m_self
);
1165 Py_XDECREF(cbh
->m_class
);
1166 wxPyEndBlockThreads();
1170 //---------------------------------------------------------------------------
1171 //---------------------------------------------------------------------------
1172 // These event classes can be derived from in Python and passed through the event
1173 // system without losing anything. They do this by keeping a reference to
1174 // themselves and some special case handling in wxPyCallback::EventThunker.
1177 wxPyEvtSelfRef::wxPyEvtSelfRef() {
1178 //m_self = Py_None; // **** We don't do normal ref counting to prevent
1179 //Py_INCREF(m_self); // circular loops...
1183 wxPyEvtSelfRef::~wxPyEvtSelfRef() {
1184 wxPyBeginBlockThreads();
1187 wxPyEndBlockThreads();
1190 void wxPyEvtSelfRef::SetSelf(PyObject
* self
, bool clone
) {
1191 wxPyBeginBlockThreads();
1199 wxPyEndBlockThreads();
1202 PyObject
* wxPyEvtSelfRef::GetSelf() const {
1208 IMPLEMENT_ABSTRACT_CLASS(wxPyEvent
, wxEvent
);
1209 IMPLEMENT_ABSTRACT_CLASS(wxPyCommandEvent
, wxCommandEvent
);
1212 wxPyEvent::wxPyEvent(int id
)
1217 wxPyEvent::wxPyEvent(const wxPyEvent
& evt
)
1220 SetSelf(evt
.m_self
, TRUE
);
1224 wxPyEvent::~wxPyEvent() {
1228 wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType
, int id
)
1229 : wxCommandEvent(commandType
, id
) {
1233 wxPyCommandEvent::wxPyCommandEvent(const wxPyCommandEvent
& evt
)
1234 : wxCommandEvent(evt
)
1236 SetSelf(evt
.m_self
, TRUE
);
1240 wxPyCommandEvent::~wxPyCommandEvent() {
1246 //---------------------------------------------------------------------------
1247 //---------------------------------------------------------------------------
1250 wxPyTimer::wxPyTimer(PyObject
* callback
) {
1255 wxPyTimer::~wxPyTimer() {
1256 wxPyBeginBlockThreads();
1258 wxPyEndBlockThreads();
1261 void wxPyTimer::Notify() {
1262 if (!func
|| func
== Py_None
) {
1266 wxPyBeginBlockThreads();
1269 PyObject
* args
= Py_BuildValue("()");
1271 result
= PyEval_CallObject(func
, args
);
1280 wxPyEndBlockThreads();
1286 //---------------------------------------------------------------------------
1287 //---------------------------------------------------------------------------
1288 // Convert a wxList to a Python List
1290 PyObject
* wxPy_ConvertList(wxListBase
* list
, const char* className
) {
1294 wxNode
* node
= list
->First();
1296 wxPyBeginBlockThreads();
1297 pyList
= PyList_New(0);
1299 wxObj
= node
->Data();
1300 pyObj
= wxPyMake_wxObject(wxObj
); //wxPyConstructObject(wxObj, className);
1301 PyList_Append(pyList
, pyObj
);
1302 node
= node
->Next();
1304 wxPyEndBlockThreads();
1308 //----------------------------------------------------------------------
1310 long wxPyGetWinHandle(wxWindow
* win
) {
1312 return (long)win
->GetHandle();
1315 // Find and return the actual X-Window.
1317 if (win
->m_wxwindow
) {
1318 GdkWindowPrivate
* bwin
= (GdkWindowPrivate
*)GTK_PIZZA(win
->m_wxwindow
)->bin_window
;
1320 return (long)bwin
->xwindow
;
1327 //----------------------------------------------------------------------
1328 // Some helper functions for typemaps in my_typemaps.i, so they won't be
1329 // included in every file over and over again...
1331 #if PYTHON_API_VERSION >= 1009
1332 static char* wxStringErrorMsg
= "String or Unicode type required";
1334 static char* wxStringErrorMsg
= "String type required";
1338 wxString
* wxString_in_helper(PyObject
* source
) {
1340 #if PYTHON_API_VERSION >= 1009 // Have Python unicode API
1341 if (!PyString_Check(source
) && !PyUnicode_Check(source
)) {
1342 PyErr_SetString(PyExc_TypeError
, wxStringErrorMsg
);
1346 if (PyUnicode_Check(source
)) {
1347 target
= new wxString(PyUnicode_AS_UNICODE(source
));
1349 // It is a string, get pointers to it and transform to unicode
1350 char* tmpPtr
; int tmpSize
;
1351 PyString_AsStringAndSize(source
, &tmpPtr
, &tmpSize
);
1352 target
= new wxString(tmpPtr
, *wxConvCurrent
, tmpSize
);
1355 char* tmpPtr
; int tmpSize
;
1356 if (PyString_AsStringAndSize(source
, &tmpPtr
, &tmpSize
) == -1) {
1357 PyErr_SetString(PyExc_TypeError
, "Unable to convert string");
1360 target
= new wxString(tmpPtr
, tmpSize
);
1361 #endif // wxUSE_UNICODE
1363 #else // No Python unicode API (1.5.2)
1364 if (!PyString_Check(source
)) {
1365 PyErr_SetString(PyExc_TypeError
, wxStringErrorMsg
);
1368 target
= new wxString(PyString_AS_STRING(source
), PyString_GET_SIZE(source
));
1374 // Similar to above except doesn't use "new" and doesn't set an exception
1375 wxString
Py2wxString(PyObject
* source
)
1378 bool doDecRef
= FALSE
;
1380 #if PYTHON_API_VERSION >= 1009 // Have Python unicode API
1381 if (!PyString_Check(source
) && !PyUnicode_Check(source
)) {
1382 // Convert to String if not one already... (TODO: Unicode too?)
1383 source
= PyObject_Str(source
);
1388 if (PyUnicode_Check(source
)) {
1389 target
= PyUnicode_AS_UNICODE(source
);
1391 // It is a string, get pointers to it and transform to unicode
1392 char* tmpPtr
; int tmpSize
;
1393 PyString_AsStringAndSize(source
, &tmpPtr
, &tmpSize
);
1394 target
= wxString(tmpPtr
, *wxConvCurrent
, tmpSize
);
1397 char* tmpPtr
; int tmpSize
;
1398 PyString_AsStringAndSize(source
, &tmpPtr
, &tmpSize
);
1399 target
= wxString(tmpPtr
, tmpSize
);
1400 #endif // wxUSE_UNICODE
1402 #else // No Python unicode API (1.5.2)
1403 if (!PyString_Check(source
)) {
1404 // Convert to String if not one already...
1405 source
= PyObject_Str(source
);
1408 target
= wxString(PyString_AS_STRING(source
), PyString_GET_SIZE(source
));
1417 // Make either a Python String or Unicode object, depending on build mode
1418 PyObject
* wx2PyString(const wxString
& src
)
1422 str
= PyUnicode_FromUnicode(src
.c_str(), src
.Len());
1424 str
= PyString_FromStringAndSize(src
.c_str(), src
.Len());
1430 //----------------------------------------------------------------------
1433 byte
* byte_LIST_helper(PyObject
* source
) {
1434 if (!PyList_Check(source
)) {
1435 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1438 int count
= PyList_Size(source
);
1439 byte
* temp
= new byte
[count
];
1441 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1444 for (int x
=0; x
<count
; x
++) {
1445 PyObject
* o
= PyList_GetItem(source
, x
);
1446 if (! PyInt_Check(o
)) {
1447 PyErr_SetString(PyExc_TypeError
, "Expected a list of integers.");
1450 temp
[x
] = (byte
)PyInt_AsLong(o
);
1456 int* int_LIST_helper(PyObject
* source
) {
1457 if (!PyList_Check(source
)) {
1458 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1461 int count
= PyList_Size(source
);
1462 int* temp
= new int[count
];
1464 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1467 for (int x
=0; x
<count
; x
++) {
1468 PyObject
* o
= PyList_GetItem(source
, x
);
1469 if (! PyInt_Check(o
)) {
1470 PyErr_SetString(PyExc_TypeError
, "Expected a list of integers.");
1473 temp
[x
] = PyInt_AsLong(o
);
1479 long* long_LIST_helper(PyObject
* source
) {
1480 if (!PyList_Check(source
)) {
1481 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1484 int count
= PyList_Size(source
);
1485 long* temp
= new long[count
];
1487 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1490 for (int x
=0; x
<count
; x
++) {
1491 PyObject
* o
= PyList_GetItem(source
, x
);
1492 if (! PyInt_Check(o
)) {
1493 PyErr_SetString(PyExc_TypeError
, "Expected a list of integers.");
1496 temp
[x
] = PyInt_AsLong(o
);
1502 char** string_LIST_helper(PyObject
* source
) {
1503 if (!PyList_Check(source
)) {
1504 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1507 int count
= PyList_Size(source
);
1508 char** temp
= new char*[count
];
1510 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1513 for (int x
=0; x
<count
; x
++) {
1514 PyObject
* o
= PyList_GetItem(source
, x
);
1515 if (! PyString_Check(o
)) {
1516 PyErr_SetString(PyExc_TypeError
, "Expected a list of strings.");
1519 temp
[x
] = PyString_AsString(o
);
1524 //--------------------------------
1525 // Part of patch from Tim Hochberg
1526 static inline bool wxPointFromObjects(PyObject
* o1
, PyObject
* o2
, wxPoint
* point
) {
1527 if (PyInt_Check(o1
) && PyInt_Check(o2
)) {
1528 point
->x
= PyInt_AS_LONG(o1
);
1529 point
->y
= PyInt_AS_LONG(o2
);
1532 if (PyFloat_Check(o1
) && PyFloat_Check(o2
)) {
1533 point
->x
= (int)PyFloat_AS_DOUBLE(o1
);
1534 point
->y
= (int)PyFloat_AS_DOUBLE(o2
);
1537 if (PyInstance_Check(o1
) || PyInstance_Check(o2
)) {
1538 // Disallow instances because they can cause havok
1541 if (PyNumber_Check(o1
) && PyNumber_Check(o2
)) {
1542 // I believe this excludes instances, so this should be safe without INCREFFing o1 and o2
1543 point
->x
= PyInt_AsLong(o1
);
1544 point
->y
= PyInt_AsLong(o2
);
1551 wxPoint
* wxPoint_LIST_helper(PyObject
* source
, int *count
) {
1552 // Putting all of the declarations here allows
1553 // us to put the error handling all in one place.
1556 PyObject
*o
, *o1
, *o2
;
1557 bool isFast
= PyList_Check(source
) || PyTuple_Check(source
);
1559 if (!PySequence_Check(source
)) {
1563 // The length of the sequence is returned in count.
1564 *count
= PySequence_Length(source
);
1569 temp
= new wxPoint
[*count
];
1571 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1574 for (x
=0; x
<*count
; x
++) {
1575 // Get an item: try fast way first.
1577 o
= PySequence_Fast_GET_ITEM(source
, x
);
1580 o
= PySequence_GetItem(source
, x
);
1586 // Convert o to wxPoint.
1587 if ((PyTuple_Check(o
) && PyTuple_GET_SIZE(o
) == 2) ||
1588 (PyList_Check(o
) && PyList_GET_SIZE(o
) == 2)) {
1589 o1
= PySequence_Fast_GET_ITEM(o
, 0);
1590 o2
= PySequence_Fast_GET_ITEM(o
, 1);
1591 if (!wxPointFromObjects(o1
, o2
, &temp
[x
])) {
1595 else if (PyInstance_Check(o
)) {
1597 if (SWIG_GetPtrObj(o
, (void **)&pt
, "_wxPoint_p")) {
1602 else if (PySequence_Check(o
) && PySequence_Length(o
) == 2) {
1603 o1
= PySequence_GetItem(o
, 0);
1604 o2
= PySequence_GetItem(o
, 1);
1605 if (!wxPointFromObjects(o1
, o2
, &temp
[x
])) {
1629 PyErr_SetString(PyExc_TypeError
, "Expected a sequence of length-2 sequences or wxPoints.");
1633 //------------------------------
1636 wxBitmap
** wxBitmap_LIST_helper(PyObject
* source
) {
1637 if (!PyList_Check(source
)) {
1638 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1641 int count
= PyList_Size(source
);
1642 wxBitmap
** temp
= new wxBitmap
*[count
];
1644 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1647 for (int x
=0; x
<count
; x
++) {
1648 PyObject
* o
= PyList_GetItem(source
, x
);
1649 if (PyInstance_Check(o
)) {
1651 if (SWIG_GetPtrObj(o
, (void **) &pt
,"_wxBitmap_p")) {
1652 PyErr_SetString(PyExc_TypeError
,"Expected _wxBitmap_p.");
1658 PyErr_SetString(PyExc_TypeError
, "Expected a list of wxBitmaps.");
1667 wxString
* wxString_LIST_helper(PyObject
* source
) {
1668 if (!PyList_Check(source
)) {
1669 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1672 int count
= PyList_Size(source
);
1673 wxString
* temp
= new wxString
[count
];
1675 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1678 for (int x
=0; x
<count
; x
++) {
1679 PyObject
* o
= PyList_GetItem(source
, x
);
1680 #if PYTHON_API_VERSION >= 1009
1681 if (! PyString_Check(o
) && ! PyUnicode_Check(o
)) {
1682 PyErr_SetString(PyExc_TypeError
, "Expected a list of string or unicode objects.");
1686 if (! PyString_Check(o
)) {
1687 PyErr_SetString(PyExc_TypeError
, "Expected a list of strings.");
1692 wxString
* pStr
= wxString_in_helper(o
);
1700 wxAcceleratorEntry
* wxAcceleratorEntry_LIST_helper(PyObject
* source
) {
1701 if (!PyList_Check(source
)) {
1702 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1705 int count
= PyList_Size(source
);
1706 wxAcceleratorEntry
* temp
= new wxAcceleratorEntry
[count
];
1708 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1711 for (int x
=0; x
<count
; x
++) {
1712 PyObject
* o
= PyList_GetItem(source
, x
);
1713 if (PyInstance_Check(o
)) {
1714 wxAcceleratorEntry
* ae
;
1715 if (SWIG_GetPtrObj(o
, (void **) &ae
,"_wxAcceleratorEntry_p")) {
1716 PyErr_SetString(PyExc_TypeError
,"Expected _wxAcceleratorEntry_p.");
1721 else if (PyTuple_Check(o
)) {
1722 PyObject
* o1
= PyTuple_GetItem(o
, 0);
1723 PyObject
* o2
= PyTuple_GetItem(o
, 1);
1724 PyObject
* o3
= PyTuple_GetItem(o
, 2);
1725 temp
[x
].Set(PyInt_AsLong(o1
), PyInt_AsLong(o2
), PyInt_AsLong(o3
));
1728 PyErr_SetString(PyExc_TypeError
, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
1736 wxPen
** wxPen_LIST_helper(PyObject
* source
) {
1737 if (!PyList_Check(source
)) {
1738 PyErr_SetString(PyExc_TypeError
, "Expected a list object.");
1741 int count
= PyList_Size(source
);
1742 wxPen
** temp
= new wxPen
*[count
];
1744 PyErr_SetString(PyExc_MemoryError
, "Unable to allocate temporary array");
1747 for (int x
=0; x
<count
; x
++) {
1748 PyObject
* o
= PyList_GetItem(source
, x
);
1749 if (PyInstance_Check(o
)) {
1751 if (SWIG_GetPtrObj(o
, (void **) &pt
,"_wxPen_p")) {
1753 PyErr_SetString(PyExc_TypeError
,"Expected _wxPen_p.");
1760 PyErr_SetString(PyExc_TypeError
, "Expected a list of wxPens.");
1768 bool _2int_seq_helper(PyObject
* source
, int* i1
, int* i2
) {
1769 bool isFast
= PyList_Check(source
) || PyTuple_Check(source
);
1772 if (!PySequence_Check(source
) || PySequence_Length(source
) != 2)
1776 o1
= PySequence_Fast_GET_ITEM(source
, 0);
1777 o2
= PySequence_Fast_GET_ITEM(source
, 1);
1780 o1
= PySequence_GetItem(source
, 0);
1781 o2
= PySequence_GetItem(source
, 1);
1784 *i1
= PyInt_AsLong(o1
);
1785 *i2
= PyInt_AsLong(o2
);
1795 bool _4int_seq_helper(PyObject
* source
, int* i1
, int* i2
, int* i3
, int* i4
) {
1796 bool isFast
= PyList_Check(source
) || PyTuple_Check(source
);
1797 PyObject
*o1
, *o2
, *o3
, *o4
;
1799 if (!PySequence_Check(source
) || PySequence_Length(source
) != 4)
1803 o1
= PySequence_Fast_GET_ITEM(source
, 0);
1804 o2
= PySequence_Fast_GET_ITEM(source
, 1);
1805 o3
= PySequence_Fast_GET_ITEM(source
, 2);
1806 o4
= PySequence_Fast_GET_ITEM(source
, 3);
1809 o1
= PySequence_GetItem(source
, 0);
1810 o2
= PySequence_GetItem(source
, 1);
1811 o3
= PySequence_GetItem(source
, 2);
1812 o4
= PySequence_GetItem(source
, 3);
1815 *i1
= PyInt_AsLong(o1
);
1816 *i2
= PyInt_AsLong(o2
);
1817 *i3
= PyInt_AsLong(o3
);
1818 *i4
= PyInt_AsLong(o4
);
1830 //----------------------------------------------------------------------
1832 bool wxSize_helper(PyObject
* source
, wxSize
** obj
) {
1834 // If source is an object instance then it may already be the right type
1835 if (PyInstance_Check(source
)) {
1837 if (SWIG_GetPtrObj(source
, (void **)&ptr
, "_wxSize_p"))
1842 // otherwise a 2-tuple of integers is expected
1843 else if (PySequence_Check(source
) && PyObject_Length(source
) == 2) {
1844 PyObject
* o1
= PySequence_GetItem(source
, 0);
1845 PyObject
* o2
= PySequence_GetItem(source
, 1);
1846 if (!PyNumber_Check(o1
) || !PyNumber_Check(o2
)) {
1851 **obj
= wxSize(PyInt_AsLong(o1
), PyInt_AsLong(o2
));
1858 PyErr_SetString(PyExc_TypeError
, "Expected a 2-tuple of integers or a wxSize object.");
1862 bool wxPoint_helper(PyObject
* source
, wxPoint
** obj
) {
1864 // If source is an object instance then it may already be the right type
1865 if (PyInstance_Check(source
)) {
1867 if (SWIG_GetPtrObj(source
, (void **)&ptr
, "_wxPoint_p"))
1872 // otherwise a length-2 sequence of integers is expected
1873 if (PySequence_Check(source
) && PySequence_Length(source
) == 2) {
1874 PyObject
* o1
= PySequence_GetItem(source
, 0);
1875 PyObject
* o2
= PySequence_GetItem(source
, 1);
1876 // This should really check for integers, not numbers -- but that would break code.
1877 if (!PyNumber_Check(o1
) || !PyNumber_Check(o2
)) {
1882 **obj
= wxPoint(PyInt_AsLong(o1
), PyInt_AsLong(o2
));
1888 PyErr_SetString(PyExc_TypeError
, "Expected a 2-tuple of integers or a wxPoint object.");
1894 bool wxRealPoint_helper(PyObject
* source
, wxRealPoint
** obj
) {
1896 // If source is an object instance then it may already be the right type
1897 if (PyInstance_Check(source
)) {
1899 if (SWIG_GetPtrObj(source
, (void **)&ptr
, "_wxRealPoint_p"))
1904 // otherwise a 2-tuple of floats is expected
1905 else if (PySequence_Check(source
) && PyObject_Length(source
) == 2) {
1906 PyObject
* o1
= PySequence_GetItem(source
, 0);
1907 PyObject
* o2
= PySequence_GetItem(source
, 1);
1908 if (!PyNumber_Check(o1
) || !PyNumber_Check(o2
)) {
1913 **obj
= wxRealPoint(PyFloat_AsDouble(o1
), PyFloat_AsDouble(o2
));
1920 PyErr_SetString(PyExc_TypeError
, "Expected a 2-tuple of floats or a wxRealPoint object.");
1927 bool wxRect_helper(PyObject
* source
, wxRect
** obj
) {
1929 // If source is an object instance then it may already be the right type
1930 if (PyInstance_Check(source
)) {
1932 if (SWIG_GetPtrObj(source
, (void **)&ptr
, "_wxRect_p"))
1937 // otherwise a 4-tuple of integers is expected
1938 else if (PySequence_Check(source
) && PyObject_Length(source
) == 4) {
1939 PyObject
* o1
= PySequence_GetItem(source
, 0);
1940 PyObject
* o2
= PySequence_GetItem(source
, 1);
1941 PyObject
* o3
= PySequence_GetItem(source
, 2);
1942 PyObject
* o4
= PySequence_GetItem(source
, 3);
1943 if (!PyNumber_Check(o1
) || !PyNumber_Check(o2
) ||
1944 !PyNumber_Check(o3
) || !PyNumber_Check(o4
)) {
1951 **obj
= wxRect(PyInt_AsLong(o1
), PyInt_AsLong(o2
),
1952 PyInt_AsLong(o3
), PyInt_AsLong(o4
));
1961 PyErr_SetString(PyExc_TypeError
, "Expected a 4-tuple of integers or a wxRect object.");
1967 bool wxColour_helper(PyObject
* source
, wxColour
** obj
) {
1969 // If source is an object instance then it may already be the right type
1970 if (PyInstance_Check(source
)) {
1972 if (SWIG_GetPtrObj(source
, (void **)&ptr
, "_wxColour_p"))
1977 // otherwise a string is expected
1978 else if (PyString_Check(source
)) {
1979 wxString
spec(PyString_AS_STRING(source
), *wxConvCurrent
);
1980 if (spec
.GetChar(0) == '#' && spec
.Length() == 7) { // It's #RRGGBB
1981 long red
, green
, blue
;
1982 red
= green
= blue
= 0;
1983 spec
.Mid(1,2).ToLong(&red
, 16);
1984 spec
.Mid(3,2).ToLong(&green
, 16);
1985 spec
.Mid(5,2).ToLong(&blue
, 16);
1987 **obj
= wxColour(red
, green
, blue
);
1990 else { // it's a colour name
1991 **obj
= wxColour(spec
);
1997 PyErr_SetString(PyExc_TypeError
,
1998 "Expected a wxColour object or a string containing a colour "
1999 "name or '#RRGGBB'.");
2004 //----------------------------------------------------------------------
2006 PyObject
* wxArrayString2PyList_helper(const wxArrayString
& arr
) {
2008 PyObject
* list
= PyList_New(0);
2009 for (size_t i
=0; i
< arr
.GetCount(); i
++) {
2011 PyObject
* str
= PyUnicode_FromUnicode(arr
[i
].c_str(), arr
[i
].Len());
2013 PyObject
* str
= PyString_FromStringAndSize(arr
[i
].c_str(), arr
[i
].Len());
2015 PyList_Append(list
, str
);
2022 PyObject
* wxArrayInt2PyList_helper(const wxArrayInt
& arr
) {
2024 PyObject
* list
= PyList_New(0);
2025 for (size_t i
=0; i
< arr
.GetCount(); i
++) {
2026 PyObject
* number
= PyInt_FromLong(arr
[i
]);
2027 PyList_Append(list
, number
);
2034 //----------------------------------------------------------------------
2035 //----------------------------------------------------------------------