#ifdef __WXMSW__
#include <wx/msw/private.h>
-#undef FindWindow
-#undef GetCharWidth
-#undef LoadAccelerators
-#undef GetClassInfo
-#undef GetClassName
+#include <wx/msw/winundef.h>
+#include <wx/msw/msvcrt.h>
#endif
#ifdef __WXGTK__
#endif
+//----------------------------------------------------------------------
+
+
+int WXDLLEXPORT wxEntryStart( int argc, char** argv );
+int WXDLLEXPORT wxEntryInitGui();
+void WXDLLEXPORT wxEntryCleanup();
+
+wxPyApp* wxPythonApp = NULL; // Global instance of application object
+
+
+#ifdef WXP_WITH_THREAD
+struct wxPyThreadState {
+ unsigned long tid;
+ PyThreadState* tstate;
+
+ wxPyThreadState(unsigned long _tid=0, PyThreadState* _tstate=NULL)
+ : tid(_tid), tstate(_tstate) {}
+};
+
+#include <wx/dynarray.h>
+WX_DECLARE_OBJARRAY(wxPyThreadState, wxPyThreadStateArray);
+#include <wx/arrimpl.cpp>
+WX_DEFINE_OBJARRAY(wxPyThreadStateArray);
+
+wxPyThreadStateArray* wxPyTStates = NULL;
+wxMutex* wxPyTMutex = NULL;
+#endif
#ifdef __WXMSW__ // If building for win32...
#endif
//----------------------------------------------------------------------
-// Class for implementing the wxp main application shell.
+// Classes for implementing the wxp main application shell.
//----------------------------------------------------------------------
-wxPyApp *wxPythonApp = NULL; // Global instance of application object
-
wxPyApp::wxPyApp() {
// printf("**** ctor\n");
// This one isn't acutally called... See __wxStart()
-bool wxPyApp::OnInit(void) {
+bool wxPyApp::OnInit() {
return FALSE;
}
-int wxPyApp::MainLoop(void) {
+
+int wxPyApp::MainLoop() {
int retval = 0;
DeletePendingObjects();
+ bool initialized = wxTopLevelWindows.GetCount() != 0;
#ifdef __WXGTK__
- m_initialized = wxTopLevelWindows.GetCount() != 0;
+ m_initialized = initialized;
#endif
- if (Initialized()) {
+ if (initialized) {
retval = wxApp::MainLoop();
- wxPythonApp->OnExit();
+ OnExit();
}
return retval;
}
+
//---------------------------------------------------------------------
//----------------------------------------------------------------------
-#ifdef __WXMSW__
-#include "wx/msw/msvcrt.h"
-#endif
-
-
-int WXDLLEXPORT wxEntryStart( int argc, char** argv );
-int WXDLLEXPORT wxEntryInitGui();
-void WXDLLEXPORT wxEntryCleanup();
-
-
-#ifdef WXP_WITH_THREAD
-PyThreadState* wxPyEventThreadState = NULL;
-#endif
-
// This is where we pick up the first part of the wxEntry functionality...
// The rest is in __wxStart and __wxCleanup. This function is called when
#ifdef WXP_WITH_THREAD
PyEval_InitThreads();
- wxPyEventThreadState = PyThreadState_Get(); // PyThreadState_New(PyThreadState_Get()->interp);
+ wxPyTStates = new wxPyThreadStateArray;
+ wxPyTMutex = new wxMutex;
#endif
// Bail out if there is already windows created. This means that the
return Py_None;
}
+
void __wxCleanup() {
wxEntryCleanup();
+ delete wxPyTMutex;
+ wxPyTMutex = NULL;
+ wxPyTStates->Empty();
+ delete wxPyTStates;
+ wxPyTStates = NULL;
}
void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) {
if (! wxPyPtrTypeMap)
wxPyPtrTypeMap = PyDict_New();
-
PyDict_SetItemString(wxPyPtrTypeMap,
(char*)commonName,
PyString_FromString((char*)ptrName));
}
-PyObject* wxPyMake_wxObject(wxObject* source) {
- PyObject* target;
+PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
+ PyObject* target = NULL;
+ bool isEvtHandler = FALSE;
if (source) {
- wxClassInfo* info = source->GetClassInfo();
- wxChar* name = (wxChar*)info->GetClassName();
- PyObject* klass = wxPyClassExists(name);
- while (info && !klass) {
- name = (wxChar*)info->GetBaseClassName1();
- info = wxClassInfo::FindClass(name);
- klass = wxPyClassExists(name);
+ // If it's derived from wxEvtHandler then there may
+ // already be a pointer to a Python object that we can use
+ // in the OOR data.
+ if (checkEvtHandler && wxIsKindOf(source, wxEvtHandler)) {
+ isEvtHandler = TRUE;
+ wxEvtHandler* eh = (wxEvtHandler*)source;
+ wxPyClientData* data = (wxPyClientData*)eh->GetClientObject();
+ if (data) {
+ target = data->m_obj;
+ Py_INCREF(target);
+ }
}
- if (info) {
- target = wxPyConstructObject(source, name, klass, FALSE);
- } else {
- wxString msg("wxPython class not found for ");
- msg += source->GetClassInfo()->GetClassName();
- PyErr_SetString(PyExc_NameError, msg.c_str());
- target = NULL;
+
+ if (! target) {
+ // Otherwise make it the old fashioned way by making a
+ // new shadow object and putting this pointer in it.
+ wxClassInfo* info = source->GetClassInfo();
+ wxChar* name = (wxChar*)info->GetClassName();
+ PyObject* klass = wxPyClassExists(name);
+ while (info && !klass) {
+ name = (wxChar*)info->GetBaseClassName1();
+ info = wxClassInfo::FindClass(name);
+ klass = wxPyClassExists(name);
+ }
+ if (info) {
+ target = wxPyConstructObject(source, name, klass, FALSE);
+ if (target && isEvtHandler)
+ ((wxEvtHandler*)source)->SetClientObject(new wxPyClientData(target));
+ } else {
+ wxString msg("wxPython class not found for ");
+ msg += source->GetClassInfo()->GetClassName();
+ PyErr_SetString(PyExc_NameError, msg.c_str());
+ target = NULL;
+ }
}
} else { // source was NULL so return None.
Py_INCREF(Py_None); target = Py_None;
return target;
}
+
+PyObject* wxPyMake_wxSizer(wxSizer* source) {
+ PyObject* target = NULL;
+
+ if (source && wxIsKindOf(source, wxSizer)) {
+ // If it's derived from wxSizer then there may
+ // already be a pointer to a Python object that we can use
+ // in the OOR data.
+ wxSizer* sz = (wxSizer*)source;
+ wxPyClientData* data = (wxPyClientData*)sz->GetClientObject();
+ if (data) {
+ target = data->m_obj;
+ Py_INCREF(target);
+ }
+ }
+ if (! target) {
+ target = wxPyMake_wxObject(source, FALSE);
+ if (target != Py_None)
+ ((wxSizer*)source)->SetClientObject(new wxPyClientData(target));
+ }
+ return target;
+}
+
+
+
//---------------------------------------------------------------------------
PyObject* wxPyConstructObject(void* ptr,
}
char buff[64]; // should always be big enough...
-
sprintf(buff, "%sPtr", className);
+
+ wxASSERT_MSG(wxPython_dict, "wxPython_dict is not set yet!!");
+
PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
if (! classobj) {
char temp[128];
//---------------------------------------------------------------------------
-static PyThreadState* myPyThreadState_Get() {
- PyThreadState* current;
- current = PyThreadState_Swap(NULL);
- PyThreadState_Swap(current);
- return current;
+// TODO: This should really be wxThread::GetCurrentId(), and I will do so
+// after I make a quick 2.3.2.1 release.
+#ifdef WXP_WITH_THREAD
+#ifdef __WXGTK__ // does wxGTK always use pthreads?
+#include <unistd.h>
+#include <pthread.h>
+#endif
+inline
+unsigned long wxPyGetCurrentThreadId() {
+#ifdef __WXMSW__
+ return (unsigned long)::GetCurrentThreadId();
+#endif
+#ifdef __WXGTK__ // does wxGTK always use pthreads?
+ return (unsigned long)pthread_self();
+#endif
+#ifdef __WXMAC__
+ ThreadID current ;
+ MacGetCurrentThread( ¤t ) ;
+ return (unsigned long)current;
+#endif
}
-bool wxPyRestoreThread() {
- // NOTE: The Python API docs state that if a thread already has the
- // interpreter lock and calls PyEval_RestoreThread again a deadlock
- // occurs, so I put in this code as a guard condition since there are
- // many possibilites for nested events and callbacks in wxPython. If
- // The current thread is our thread, then we can assume that we
- // already have the lock. (I hope!)
- //
-#ifdef WXP_WITH_THREAD
- if (wxPyEventThreadState != myPyThreadState_Get()) {
- PyEval_AcquireThread(wxPyEventThreadState);
- return TRUE;
+
+static
+PyThreadState* wxPyGetThreadState() {
+ unsigned long ctid = wxPyGetCurrentThreadId();
+ PyThreadState* tstate = NULL;
+
+ wxPyTMutex->Lock();
+ for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
+ wxPyThreadState& info = wxPyTStates->Item(i);
+ if (info.tid == ctid) {
+ tstate = info.tstate;
+ break;
+ }
}
- else
+ wxPyTMutex->Unlock();
+ wxASSERT_MSG(tstate, "PyThreadState should not be NULL!");
+ return tstate;
+}
+
+static
+void wxPySaveThreadState(PyThreadState* tstate) {
+ unsigned long ctid = wxPyGetCurrentThreadId();
+ wxPyTMutex->Lock();
+ for(size_t i=0; i < wxPyTStates->GetCount(); i++) {
+ wxPyThreadState& info = wxPyTStates->Item(i);
+ if (info.tid == ctid) {
+ info.tstate = tstate;
+ wxPyTMutex->Unlock();
+ return;
+ }
+ }
+ // not found, so add it...
+ wxPyTStates->Add(new wxPyThreadState(ctid, tstate));
+ wxPyTMutex->Unlock();
+}
+
+#endif
+
+
+// Calls from Python to wxWindows code are wrapped in calls to these
+// functions:
+
+PyThreadState* wxPyBeginAllowThreads() {
+#ifdef WXP_WITH_THREAD
+ PyThreadState* saved = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS;
+ wxPySaveThreadState(saved);
+ return saved;
+#else
+ return NULL;
+#endif
+}
+
+void wxPyEndAllowThreads(PyThreadState* saved) {
+#ifdef WXP_WITH_THREAD
+ PyEval_RestoreThread(saved); // Py_END_ALLOW_THREADS;
#endif
- return FALSE;
}
-void wxPySaveThread(bool doSave) {
+
+// Calls from wxWindows back to Python code, or even any PyObject
+// manipulations, PyDECREF's and etc. are wrapped in calls to these functions:
+
+void wxPyBeginBlockThreads() {
#ifdef WXP_WITH_THREAD
- if (doSave) {
- PyEval_ReleaseThread(wxPyEventThreadState);
- }
+ PyThreadState* tstate = wxPyGetThreadState();
+ PyEval_RestoreThread(tstate);
#endif
}
+
+void wxPyEndBlockThreads() {
+#ifdef WXP_WITH_THREAD
+ PyThreadState* tstate = PyEval_SaveThread();
+ // Is there any need to save it again?
+#endif
+}
+
+
//---------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
}
wxPyCallback::~wxPyCallback() {
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
Py_DECREF(m_func);
- wxPySaveThread(doSave);
+ wxPyEndBlockThreads();
}
PyObject* tuple;
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
wxString className = event.GetClassInfo()->GetClassName();
if (className == "wxPyEvent")
} else {
PyErr_Print();
}
- wxPySaveThread(doSave);
+ wxPyEndBlockThreads();
}
}
-// If the object (m_self) has an attibute of the given name, and if that
-// attribute is a method, and if that method's class is not from a base class,
-// then we'll save a pointer to the method so callCallback can call it.
+#if PYTHON_API_VERSION >= 1011
+
+// Prior to Python 2.2 PyMethod_GetClass returned the class object
+// in which the method was defined. Starting with 2.2 it returns
+// "class that asked for the method" which seems totally bogus to me
+// but apprently if fixes some obscure problem waiting to happen in
+// Python. Since the API was not documented Guido and the gang felt
+// safe in changing it. Needless to say that totally screwed up the
+// logic below in wxPyCallbackHelper::findCallback, hence this icky
+// code to find the class where the method is actuallt defined...
+
+static
+PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name)
+{
+ int i, n;
+
+ if (PyType_Check(klass)) { // new style classes
+ // This code is borrowed/adapted from _PyType_Lookup in typeobject.c
+ // (TODO: This part is not tested yet, so I'm not sure it is correct...)
+ PyTypeObject* type = (PyTypeObject*)klass;
+ PyObject *mro, *res, *base, *dict;
+ /* Look in tp_dict of types in MRO */
+ mro = type->tp_mro;
+ assert(PyTuple_Check(mro));
+ n = PyTuple_GET_SIZE(mro);
+ for (i = 0; i < n; i++) {
+ base = PyTuple_GET_ITEM(mro, i);
+ if (PyClass_Check(base))
+ dict = ((PyClassObject *)base)->cl_dict;
+ else {
+ assert(PyType_Check(base));
+ dict = ((PyTypeObject *)base)->tp_dict;
+ }
+ assert(dict && PyDict_Check(dict));
+ res = PyDict_GetItem(dict, name);
+ if (res != NULL)
+ return base;
+ }
+ return NULL;
+ }
+
+ else if (PyClass_Check(klass)) { // old style classes
+ // This code is borrowed/adapted from class_lookup in classobject.c
+ PyClassObject* cp = (PyClassObject*)klass;
+ PyObject *value = PyDict_GetItem(cp->cl_dict, name);
+ if (value != NULL) {
+ return (PyObject*)cp;
+ }
+ n = PyTuple_Size(cp->cl_bases);
+ for (i = 0; i < n; i++) {
+ PyObject* base = PyTuple_GetItem(cp->cl_bases, i);
+ PyObject *v = PyFindClassWithAttr(base, name);
+ if (v != NULL)
+ return v;
+ }
+ return NULL;
+ }
+}
+#endif
+
+
+static
+PyObject* PyMethod_GetDefiningClass(PyObject* method, const char* name)
+{
+ PyObject* mgc = PyMethod_GET_CLASS(method);
+
+#if PYTHON_API_VERSION <= 1010 // prior to Python 2.2, the easy way
+ return mgc;
+#else // 2.2 and after, the hard way...
+
+ PyObject* nameo = PyString_FromString(name);
+ PyObject* klass = PyFindClassWithAttr(mgc, nameo);
+ Py_DECREF(nameo);
+ return klass;
+#endif
+}
+
+
+
bool wxPyCallbackHelper::findCallback(const char* name) const {
wxPyCallbackHelper* self = (wxPyCallbackHelper*)this; // cast away const
self->m_lastFound = NULL;
+
+ // If the object (m_self) has an attibute of the given name...
if (m_self && PyObject_HasAttrString(m_self, (char*)name)) {
- PyObject* method;
+ PyObject *method, *klass;
method = PyObject_GetAttrString(m_self, (char*)name);
+ // ...and if that attribute is a method, and if that method's class is
+ // not from a base class...
if (PyMethod_Check(method) &&
- ((PyMethod_GET_CLASS(method) == m_class) ||
- PyClass_IsSubclass(PyMethod_GET_CLASS(method), m_class))) {
+ (klass = PyMethod_GetDefiningClass(method, (char*)name)) != NULL &&
+ ((klass == m_class) || PyClass_IsSubclass(klass, m_class))) {
+ // ...then we'll save a pointer to the method so callCallback can call it.
self->m_lastFound = method;
}
else {
}
-void wxPyCBH_setSelf(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref) {
+void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref) {
cbh.setSelf(self, klass, incref);
}
void wxPyCBH_delete(wxPyCallbackHelper* cbh) {
- bool doSave = wxPyRestoreThread();
if (cbh->m_incRef) {
+ wxPyBeginBlockThreads();
Py_XDECREF(cbh->m_self);
Py_XDECREF(cbh->m_class);
+ wxPyEndBlockThreads();
}
- wxPySaveThread(doSave);
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
-// These classes can be derived from in Python and passed through the event
+// These event classes can be derived from in Python and passed through the event
// system without losing anything. They do this by keeping a reference to
// themselves and some special case handling in wxPyCallback::EventThunker.
}
wxPyEvtSelfRef::~wxPyEvtSelfRef() {
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
if (m_cloned)
Py_DECREF(m_self);
- wxPySaveThread(doSave);
+ wxPyEndBlockThreads();
}
void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) {
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
if (m_cloned)
Py_DECREF(m_self);
m_self = self;
Py_INCREF(m_self);
m_cloned = TRUE;
}
- wxPySaveThread(doSave);
+ wxPyEndBlockThreads();
}
PyObject* wxPyEvtSelfRef::GetSelf() const {
}
+IMPLEMENT_ABSTRACT_CLASS(wxPyEvent, wxEvent);
+IMPLEMENT_ABSTRACT_CLASS(wxPyCommandEvent, wxCommandEvent);
+
+
wxPyEvent::wxPyEvent(int id)
: wxEvent(id) {
}
-wxPyEvent::~wxPyEvent() {
-}
-// This one is so the event object can be Cloned...
-void wxPyEvent::CopyObject(wxObject& dest) const {
- wxEvent::CopyObject(dest);
- ((wxPyEvent*)&dest)->SetSelf(m_self, TRUE);
+wxPyEvent::wxPyEvent(const wxPyEvent& evt)
+ : wxEvent(evt)
+{
+ SetSelf(evt.m_self, TRUE);
}
-IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxEvent);
+wxPyEvent::~wxPyEvent() {
+}
wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id)
: wxCommandEvent(commandType, id) {
}
-wxPyCommandEvent::~wxPyCommandEvent() {
-}
-void wxPyCommandEvent::CopyObject(wxObject& dest) const {
- wxCommandEvent::CopyObject(dest);
- ((wxPyCommandEvent*)&dest)->SetSelf(m_self, TRUE);
+wxPyCommandEvent::wxPyCommandEvent(const wxPyCommandEvent& evt)
+ : wxCommandEvent(evt)
+{
+ SetSelf(evt.m_self, TRUE);
}
-IMPLEMENT_DYNAMIC_CLASS(wxPyCommandEvent, wxCommandEvent);
+wxPyCommandEvent::~wxPyCommandEvent() {
+}
+
}
wxPyTimer::~wxPyTimer() {
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
Py_DECREF(func);
- wxPySaveThread(doSave);
+ wxPyEndBlockThreads();
}
void wxPyTimer::Notify() {
wxTimer::Notify();
}
else {
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
PyObject* result;
PyObject* args = Py_BuildValue("()");
PyErr_Print();
}
- wxPySaveThread(doSave);
+ wxPyEndBlockThreads();
}
}
wxObject* wxObj;
wxNode* node = list->First();
- bool doSave = wxPyRestoreThread();
+ wxPyBeginBlockThreads();
pyList = PyList_New(0);
while (node) {
wxObj = node->Data();
PyList_Append(pyList, pyObj);
node = node->Next();
}
- wxPySaveThread(doSave);
+ wxPyEndBlockThreads();
return pyList;
}
}
-#if PYTHON_API_VERSION < 1009
-#define PySequence_Fast_GET_ITEM(o, i)\
- (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
-#endif
-
wxPoint* wxPoint_LIST_helper(PyObject* source, int *count) {
// Putting all of the declarations here allows
// us to put the error handling all in one place.
int x;
wxPoint* temp;
PyObject *o, *o1, *o2;
- int isFast = PyList_Check(source) || PyTuple_Check(source);
+ bool isFast = PyList_Check(source) || PyTuple_Check(source);
- // The length of the sequence is returned in count.
if (!PySequence_Check(source)) {
goto error0;
}
+
+ // The length of the sequence is returned in count.
*count = PySequence_Length(source);
if (*count < 0) {
goto error0;
}
for (int x=0; x<count; x++) {
PyObject* o = PyList_GetItem(source, x);
+#if PYTHON_API_VERSION >= 1009
+ if (! PyString_Check(o) && ! PyUnicode_Check(o)) {
+ PyErr_SetString(PyExc_TypeError, "Expected a list of string or unicode objects.");
+ return NULL;
+ }
+
+ char* buff;
+ int length;
+ if (PyString_AsStringAndSize(o, &buff, &length) == -1)
+ return NULL;
+ temp[x] = wxString(buff, length);
+#else
if (! PyString_Check(o)) {
PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
return NULL;
}
temp[x] = PyString_AsString(o);
+#endif
}
return temp;
}
}
+wxPen** wxPen_LIST_helper(PyObject* source) {
+ if (!PyList_Check(source)) {
+ PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+ return NULL;
+ }
+ int count = PyList_Size(source);
+ wxPen** temp = new wxPen*[count];
+ if (!temp) {
+ PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+ return NULL;
+ }
+ for (int x=0; x<count; x++) {
+ PyObject* o = PyList_GetItem(source, x);
+ if (PyInstance_Check(o)) {
+ wxPen* pt;
+ if (SWIG_GetPtrObj(o, (void **) &pt,"_wxPen_p")) {
+ delete temp;
+ PyErr_SetString(PyExc_TypeError,"Expected _wxPen_p.");
+ return NULL;
+ }
+ temp[x] = pt;
+ }
+ else {
+ delete temp;
+ PyErr_SetString(PyExc_TypeError, "Expected a list of wxPens.");
+ return NULL;
+ }
+ }
+ return temp;
+}
+
+
+bool _2int_seq_helper(PyObject* source, int* i1, int* i2) {
+ bool isFast = PyList_Check(source) || PyTuple_Check(source);
+ PyObject *o1, *o2;
+
+ if (!PySequence_Check(source) || PySequence_Length(source) != 2)
+ return FALSE;
+
+ if (isFast) {
+ o1 = PySequence_Fast_GET_ITEM(source, 0);
+ o2 = PySequence_Fast_GET_ITEM(source, 1);
+ }
+ else {
+ o1 = PySequence_GetItem(source, 0);
+ o2 = PySequence_GetItem(source, 1);
+ }
+
+ *i1 = PyInt_AsLong(o1);
+ *i2 = PyInt_AsLong(o2);
+
+ if (! isFast) {
+ Py_DECREF(o1);
+ Py_DECREF(o2);
+ }
+ return TRUE;
+}
+
+
+bool _4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4) {
+ bool isFast = PyList_Check(source) || PyTuple_Check(source);
+ PyObject *o1, *o2, *o3, *o4;
+
+ if (!PySequence_Check(source) || PySequence_Length(source) != 4)
+ return FALSE;
+
+ if (isFast) {
+ o1 = PySequence_Fast_GET_ITEM(source, 0);
+ o2 = PySequence_Fast_GET_ITEM(source, 1);
+ o3 = PySequence_Fast_GET_ITEM(source, 2);
+ o4 = PySequence_Fast_GET_ITEM(source, 3);
+ }
+ else {
+ o1 = PySequence_GetItem(source, 0);
+ o2 = PySequence_GetItem(source, 1);
+ o3 = PySequence_GetItem(source, 2);
+ o4 = PySequence_GetItem(source, 3);
+ }
+
+ *i1 = PyInt_AsLong(o1);
+ *i2 = PyInt_AsLong(o2);
+ *i3 = PyInt_AsLong(o3);
+ *i4 = PyInt_AsLong(o4);
+
+ if (! isFast) {
+ Py_DECREF(o1);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ Py_DECREF(o4);
+ }
+ return TRUE;
+}
+
//----------------------------------------------------------------------
if (PySequence_Check(source) && PySequence_Length(source) == 2) {
PyObject* o1 = PySequence_GetItem(source, 0);
PyObject* o2 = PySequence_GetItem(source, 1);
- // This should really check for integers, not numbers -- but that would break code.
- if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
- Py_DECREF(o1);
- Py_DECREF(o2);
- goto error;
- }
- **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
- Py_DECREF(o1);
- Py_DECREF(o2);
+ // This should really check for integers, not numbers -- but that would break code.
+ if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
+ Py_DECREF(o1);
+ Py_DECREF(o2);
+ goto error;
+ }
+ **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
+ Py_DECREF(o1);
+ Py_DECREF(o2);
return TRUE;
}
error:
//----------------------------------------------------------------------
+
+PyObject* wxArrayString2PyList_helper(const wxArrayString& arr) {
+
+ PyObject* list = PyList_New(0);
+ for (size_t i=0; i < arr.GetCount(); i++) {
+ PyObject* str = PyString_FromString(arr[i].c_str());
+ PyList_Append(list, str);
+ Py_DECREF(str);
+ }
+ return list;
+}
+
+
//----------------------------------------------------------------------
//----------------------------------------------------------------------
projects / wxWidgets.git / blobdiff