X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9d8bd15f997f3595f6390fcf6a61bd0bf53eedb2..2463329cd36c305f4007445049a89439fb7e62a9:/utils/wxPython/src/helpers.cpp?ds=sidebyside diff --git a/utils/wxPython/src/helpers.cpp b/utils/wxPython/src/helpers.cpp index 09ead8df34..863718df74 100644 --- a/utils/wxPython/src/helpers.cpp +++ b/utils/wxPython/src/helpers.cpp @@ -10,14 +10,12 @@ // Licence: wxWindows license ///////////////////////////////////////////////////////////////////////////// - -#ifdef __WXGTK__ -#include -#endif +#include // get the correct definition of NULL #undef DEBUG #include #include "helpers.h" + #ifdef __WXMSW__ #include #undef FindWindow @@ -26,7 +24,10 @@ #undef GetClassInfo #undef GetClassName #endif -#include + +#ifdef __WXGTK__ +#include +#endif //--------------------------------------------------------------------------- @@ -74,7 +75,7 @@ wxPyApp::~wxPyApp() { // This one isn't acutally called... See __wxStart() bool wxPyApp::OnInit(void) { - return false; + return FALSE; } int wxPyApp::MainLoop(void) { @@ -259,7 +260,7 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) //--------------------------------------------------------------------------- -PyObject* wxPyConstructObject(void* ptr, char* className) { +PyObject* wxPyConstructObject(void* ptr, const char* className) { char buff[64]; // should always be big enough... char swigptr[64]; @@ -282,37 +283,31 @@ PyObject* wxPyConstructObject(void* ptr, char* className) { //--------------------------------------------------------------------------- -//static bool _wxPyInEvent = false; -//static unsigned int _wxPyNestCount = 0; +static unsigned int _wxPyNestCount = 0; + +static PyThreadState* myPyThreadState_Get() { + PyThreadState* current; + current = PyThreadState_Swap(NULL); + PyThreadState_Swap(current); + return current; +} -HELPEREXPORT bool wxPyRestoreThread() { -// #ifdef WXP_WITH_THREAD -// //if (wxPyEventThreadState != PyThreadState_Get()) { -// if (! _wxPyInEvent) { -// PyEval_RestoreThread(wxPyEventThreadState); -// _wxPyInEvent = true; -// return TRUE; -// } else -// #endif -// return FALSE; +HELPEREXPORT 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 the above code as a guard condition since there are - // many possibilites for nested events and callbacks in wxPython. + // 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!) // - // Unfortunately, it seems like somebody was lying (or I'm not - // understanding...) because each of the nested calls to this function - // MUST call PyEval_RestoreThread or Python pukes with a thread error (at - // least on Win32.) - // - // until I know better, this is how I am doing it instead: #ifdef WXP_WITH_THREAD - PyEval_RestoreThread(wxPyEventThreadState); -// _wxPyNestCount += 1; -// if (_wxPyNestCount == 1) -// return TRUE; -// else + _wxPyNestCount += 1; + if (wxPyEventThreadState != myPyThreadState_Get()) { + PyEval_RestoreThread(wxPyEventThreadState); + return TRUE; + } + else #endif return FALSE; } @@ -320,11 +315,10 @@ HELPEREXPORT bool wxPyRestoreThread() { HELPEREXPORT void wxPySaveThread(bool doSave) { #ifdef WXP_WITH_THREAD -// if (doSave) { + if (doSave) { wxPyEventThreadState = PyEval_SaveThread(); -// _wxPyInEvent = false; -// } -// _wxPyNestCount -= 1; + } + _wxPyNestCount -= 1; #endif } @@ -351,7 +345,6 @@ wxPyCallback::~wxPyCallback() { - // This function is used for all events destined for Python event handlers. void wxPyCallback::EventThunker(wxEvent& event) { wxPyCallback* cb = (wxPyCallback*)event.m_callbackUserData; @@ -362,7 +355,14 @@ void wxPyCallback::EventThunker(wxEvent& event) { bool doSave = wxPyRestoreThread(); - arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName()); + wxString className = event.GetClassInfo()->GetClassName(); + + if (className == "wxPyEvent") + arg = ((wxPyEvent*)&event)->GetSelf(); + else if (className == "wxPyCommandEvent") + arg = ((wxPyCommandEvent*)&event)->GetSelf(); + else + arg = wxPyConstructObject((void*)&event, className); tuple = PyTuple_New(1); PyTuple_SET_ITEM(tuple, 0, arg); @@ -383,12 +383,14 @@ void wxPyCallback::EventThunker(wxEvent& event) { wxPyCallbackHelper::wxPyCallbackHelper() { m_self = NULL; m_lastFound = NULL; + m_incRef = FALSE; } wxPyCallbackHelper::~wxPyCallbackHelper() { bool doSave = wxPyRestoreThread(); - Py_XDECREF(m_self); + if (m_incRef) + Py_XDECREF(m_self); wxPySaveThread(doSave); } @@ -402,6 +404,7 @@ wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) { void wxPyCallbackHelper::setSelf(PyObject* self, int incref) { m_self = self; + m_incRef = incref; if (incref) Py_INCREF(m_self); } @@ -444,6 +447,78 @@ PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) { +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +// These classes can be derived from in Python and passed through the event +// system without loosing anything. They do this by keeping a reference to +// themselves and some special case handling in wxPyCallback::EventThunker. + + +wxPyEvtSelfRef::wxPyEvtSelfRef() { + //m_self = Py_None; // **** We don't do normal ref counting to prevent + //Py_INCREF(m_self); // circular loops... + m_cloned = false; +} + +wxPyEvtSelfRef::~wxPyEvtSelfRef() { + bool doSave = wxPyRestoreThread(); + if (m_cloned) + Py_DECREF(m_self); + wxPySaveThread(doSave); +} + +void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) { + bool doSave = wxPyRestoreThread(); + if (m_cloned) + Py_DECREF(m_self); + m_self = self; + if (clone) { + Py_INCREF(m_self); + m_cloned = TRUE; + } + wxPySaveThread(doSave); +} + +PyObject* wxPyEvtSelfRef::GetSelf() const { + Py_INCREF(m_self); + return m_self; +} + + +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); +} + + +IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxEvent); + + +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); +} + + +IMPLEMENT_DYNAMIC_CLASS(wxPyCommandEvent, wxCommandEvent); + + + //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- @@ -482,7 +557,7 @@ void wxPyTimer::Notify() { //--------------------------------------------------------------------------- // Convert a wxList to a Python List -PyObject* wxPy_ConvertList(wxListBase* list, char* className) { +PyObject* wxPy_ConvertList(wxListBase* list, const char* className) { PyObject* pyList; PyObject* pyObj; wxObject* wxObj;