#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
+//----------------------------------------------------------------------
+
+#ifdef __WXGTK__
+int WXDLLEXPORT wxEntryStart( int& argc, char** argv );
+#else
+int WXDLLEXPORT wxEntryStart( int argc, char** argv );
+#endif
+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
-PyInterpreterState* wxPyInterpreter = 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();
- wxPyInterpreter = 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();
+#ifdef WXP_WITH_THREAD
+ delete wxPyTMutex;
+ wxPyTMutex = NULL;
+ wxPyTStates->Empty();
+ delete wxPyTStates;
+ wxPyTStates = NULL;
+#endif
}
#ifdef __WXMOTIF__
#define wxPlatform "__WXMOTIF__"
#endif
-#ifdef __WXQT__
-#define wxPlatform "__WXQT__"
+#ifdef __WXX11__
+#define wxPlatform "__WXX11__"
#endif
#ifdef __WXGTK__
#define wxPlatform "__WXGTK__"
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* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) {
PyObject* target = NULL;
bool isEvtHandler = FALSE;
if (source) {
// If it's derived from wxEvtHandler then there may
- // already be a pointer to a Python objec that we can use.
- if (wxIsKindOf(source, wxEvtHandler)) {
+ // 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) {
Py_INCREF(target);
}
}
- else if (wxIsKindOf(source, wxSizer)) {
- // wxSizers also track the original object
- wxSizer* sz = (wxSizer*)source;
- wxPyClientData* data = (wxPyClientData*)sz->GetClientObject();
- if (data) {
- target = data->m_obj;
- Py_INCREF(target);
- }
- }
if (! target) {
// Otherwise make it the old fashioned way by making a
}
+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];
//---------------------------------------------------------------------------
-wxPyTState* wxPyBeginBlockThreads() {
- wxPyTState* state = NULL;
#ifdef WXP_WITH_THREAD
- if (1) { // Can I check if I've already got the lock?
- state = new wxPyTState;
- PyEval_AcquireLock();
- state->newState = PyThreadState_New(wxPyInterpreter);
- state->prevState = PyThreadState_Swap(state->newState);
+inline
+unsigned long wxPyGetCurrentThreadId() {
+ return wxThread::GetCurrentId();
+}
+
+static PyThreadState* gs_shutdownTState;
+static
+PyThreadState* wxPyGetThreadState() {
+ if (wxPyTMutex == NULL) // Python is shutting down...
+ return gs_shutdownTState;
+
+ 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;
+ }
+ }
+ wxPyTMutex->Unlock();
+ wxASSERT_MSG(tstate, "PyThreadState should not be NULL!");
+ return tstate;
+}
+
+static
+void wxPySaveThreadState(PyThreadState* tstate) {
+ if (wxPyTMutex == NULL) { // Python is shutting down, assume a single thread...
+ gs_shutdownTState = tstate;
+ return;
+ }
+ 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
- return state;
}
+void wxPyEndAllowThreads(PyThreadState* saved) {
+#ifdef WXP_WITH_THREAD
+ PyEval_RestoreThread(saved); // Py_END_ALLOW_THREADS;
+#endif
+}
+
+
+
+// Calls from wxWindows back to Python code, or even any PyObject
+// manipulations, PyDECREF's and etc. are wrapped in calls to these functions:
-void wxPyEndBlockThreads(wxPyTState* state) {
+void wxPyBeginBlockThreads() {
#ifdef WXP_WITH_THREAD
- if (state) {
- PyThreadState_Swap(state->prevState);
- PyThreadState_Clear(state->newState);
- PyEval_ReleaseLock();
- PyThreadState_Delete(state->newState);
- delete state;
- }
+ 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
}
}
wxPyCallback::~wxPyCallback() {
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
Py_DECREF(m_func);
- wxPyEndBlockThreads(state);
+ wxPyEndBlockThreads();
}
PyObject* tuple;
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
wxString className = event.GetClassInfo()->GetClassName();
if (className == "wxPyEvent")
} else {
PyErr_Print();
}
- wxPyEndBlockThreads(state);
+ 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_delete(wxPyCallbackHelper* cbh) {
if (cbh->m_incRef) {
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
Py_XDECREF(cbh->m_self);
Py_XDECREF(cbh->m_class);
- wxPyEndBlockThreads(state);
+ wxPyEndBlockThreads();
}
}
}
wxPyEvtSelfRef::~wxPyEvtSelfRef() {
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
if (m_cloned)
Py_DECREF(m_self);
- wxPyEndBlockThreads(state);
+ wxPyEndBlockThreads();
}
void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) {
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
if (m_cloned)
Py_DECREF(m_self);
m_self = self;
Py_INCREF(m_self);
m_cloned = TRUE;
}
- wxPyEndBlockThreads(state);
+ wxPyEndBlockThreads();
}
PyObject* wxPyEvtSelfRef::GetSelf() const {
}
wxPyTimer::~wxPyTimer() {
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
Py_DECREF(func);
- wxPyEndBlockThreads(state);
+ wxPyEndBlockThreads();
}
void wxPyTimer::Notify() {
wxTimer::Notify();
}
else {
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
PyObject* result;
PyObject* args = Py_BuildValue("()");
PyErr_Print();
}
- wxPyEndBlockThreads(state);
+ wxPyEndBlockThreads();
}
}
wxObject* wxObj;
wxNode* node = list->First();
- wxPyTState* state = wxPyBeginBlockThreads();
+ wxPyBeginBlockThreads();
pyList = PyList_New(0);
while (node) {
wxObj = node->Data();
PyList_Append(pyList, pyObj);
node = node->Next();
}
- wxPyEndBlockThreads(state);
+ wxPyEndBlockThreads();
return pyList;
}
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:
for (size_t i=0; i < arr.GetCount(); i++) {
PyObject* str = PyString_FromString(arr[i].c_str());
PyList_Append(list, str);
- // TODO: Check refcount on str...
+ Py_DECREF(str);
+ }
+ return list;
+}
+
+
+PyObject* wxArrayInt2PyList_helper(const wxArrayInt& arr) {
+
+ PyObject* list = PyList_New(0);
+ for (size_t i=0; i < arr.GetCount(); i++) {
+ PyObject* number = PyInt_FromLong(arr[i]);
+ PyList_Append(list, number);
+ Py_DECREF(number);
}
return list;
}
projects / wxWidgets.git / blobdiff