X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c368d904fc27d35ae1e533155e2154dc496432e4..6bff4be599aefb32d69734849e4c8fc1529f7868:/wxPython/src/helpers.cpp diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp index 6d0cb21730..187a0673c8 100644 --- a/wxPython/src/helpers.cpp +++ b/wxPython/src/helpers.cpp @@ -29,24 +29,9 @@ #include #include #include -//#include -//#include -//#include - -//extern GtkWidget *wxRootWindow; - #endif -//--------------------------------------------------------------------------- - -//wxHashTable* wxPyWindows = NULL; - - -wxPoint wxPyDefaultPosition; //wxDefaultPosition); -wxSize wxPyDefaultSize; //wxDefaultSize); -wxString wxPyEmptyStr(""); - #ifdef __WXMSW__ // If building for win32... @@ -105,15 +90,19 @@ int wxPyApp::MainLoop(void) { //--------------------------------------------------------------------- //---------------------------------------------------------------------- +#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; +PyInterpreterState* wxPyInterpreter = NULL; #endif -static char* __nullArgv[1] = { 0 }; // This is where we pick up the first part of the wxEntry functionality... @@ -121,9 +110,14 @@ static char* __nullArgv[1] = { 0 }; // wxcmodule is imported. (Before there is a wxApp object.) void __wxPreStart() { + +#ifdef __WXMSW__ +// wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF); +#endif + #ifdef WXP_WITH_THREAD PyEval_InitThreads(); - wxPyEventThreadState = PyThreadState_Get(); + wxPyInterpreter = PyThreadState_Get()->interp; #endif // Bail out if there is already windows created. This means that the @@ -133,13 +127,17 @@ void __wxPreStart() return; + int argc = 0; + char** argv = NULL; PyObject* sysargv = PySys_GetObject("argv"); - int argc = PyList_Size(sysargv); - char** argv = new char*[argc+1]; - int x; - for(x=0; x 0) { PyErr_SetString(PyExc_TypeError, "Only 1 wxApp per process!"); return NULL; } - +#endif // This is the next part of the wxEntry functionality... + int argc = 0; + char** argv = NULL; PyObject* sysargv = PySys_GetObject("argv"); - int argc = PyList_Size(sysargv); - char** argv = new char*[argc+1]; - int x; - for(x=0; xargc = argc; wxPythonApp->argv = argv; @@ -209,7 +211,9 @@ void __wxCleanup() { -PyObject* wxPython_dict; +static PyObject* wxPython_dict = NULL; +static PyObject* wxPyPtrTypeMap = NULL; + PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) { @@ -220,6 +224,12 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!"); return NULL; } + + if (! wxPyPtrTypeMap) + wxPyPtrTypeMap = PyDict_New(); + PyDict_SetItemString(wxPython_dict, "__wxPyPtrTypeMap", wxPyPtrTypeMap); + + #ifdef __WXMOTIF__ #define wxPlatform "__WXMOTIF__" #endif @@ -243,78 +253,184 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) } +//--------------------------------------------------------------------------- +// Stuff used by OOR to find the right wxPython class type to return and to +// build it. + + +// The pointer type map is used when the "pointer" type name generated by SWIG +// is not the same as the shadow class name, for example wxPyTreeCtrl +// vs. wxTreeCtrl. It needs to be referenced in Python as well as from C++, +// so we'll just make it a Python dictionary in the wx module's namespace. +void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) { + if (! wxPyPtrTypeMap) + wxPyPtrTypeMap = PyDict_New(); + + PyDict_SetItemString(wxPyPtrTypeMap, + (char*)commonName, + PyString_FromString((char*)ptrName)); +} + + + +PyObject* wxPyClassExists(const char* className) { + + if (!className) + return NULL; + + char buff[64]; // should always be big enough... + + sprintf(buff, "%sPtr", className); + PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff); + + return classobj; // returns NULL if not found +} + + +PyObject* wxPyMake_wxObject(wxObject* source) { + 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)) { + wxEvtHandler* eh = (wxEvtHandler*)source; + wxPyClientData* data = (wxPyClientData*)eh->GetClientObject(); + if (data) { + target = data->m_obj; + 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 + // 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* wxPyConstructObject(void* ptr, const char* className, + PyObject* klass, int setThisOwn) { - char buff[64]; // should always be big enough... - char swigptr[64]; - sprintf(buff, "_%s_p", className); - SWIG_MakePtr(swigptr, ptr, buff); + PyObject* obj; + PyObject* arg; + PyObject* item; + char swigptr[64]; // should always be big enough... + char buff[64]; - sprintf(buff, "%sPtr", className); - PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff); - if (! classobj) { - Py_INCREF(Py_None); - return Py_None; + if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)className)) != NULL) { + className = PyString_AsString(item); } + sprintf(buff, "_%s_p", className); + SWIG_MakePtr(swigptr, ptr, buff); - PyObject* arg = Py_BuildValue("(s)", swigptr); - PyObject* obj = PyInstance_New(classobj, arg, NULL); + arg = Py_BuildValue("(s)", swigptr); + obj = PyInstance_New(klass, arg, NULL); Py_DECREF(arg); if (setThisOwn) { - PyObject_SetAttrString(obj, "thisown", PyInt_FromLong(1)); + PyObject* one = PyInt_FromLong(1); + PyObject_SetAttrString(obj, "thisown", one); + Py_DECREF(one); } return obj; } -//--------------------------------------------------------------------------- -static unsigned int _wxPyNestCount = 0; +PyObject* wxPyConstructObject(void* ptr, + const char* className, + int setThisOwn) { + PyObject* obj; + + if (!ptr) { + Py_INCREF(Py_None); + return Py_None; + } + + char buff[64]; // should always be big enough... -static PyThreadState* myPyThreadState_Get() { - PyThreadState* current; - current = PyThreadState_Swap(NULL); - PyThreadState_Swap(current); - return current; + sprintf(buff, "%sPtr", className); + PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff); + if (! classobj) { + char temp[128]; + sprintf(temp, + "*** Unknown class name %s, tell Robin about it please ***", + buff); + obj = PyString_FromString(temp); + return obj; + } + + return wxPyConstructObject(ptr, className, classobj, setThisOwn); } +//--------------------------------------------------------------------------- -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 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!) - // + +wxPyTState* wxPyBeginBlockThreads() { + wxPyTState* state = NULL; #ifdef WXP_WITH_THREAD - _wxPyNestCount += 1; - if (wxPyEventThreadState != myPyThreadState_Get()) { - PyEval_RestoreThread(wxPyEventThreadState); - return TRUE; + 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); } - else #endif - return FALSE; + return state; } -HELPEREXPORT void wxPySaveThread(bool doSave) { +void wxPyEndBlockThreads(wxPyTState* state) { #ifdef WXP_WITH_THREAD - if (doSave) { - wxPyEventThreadState = PyEval_SaveThread(); + if (state) { + PyThreadState_Swap(state->prevState); + PyThreadState_Clear(state->newState); + PyEval_ReleaseLock(); + PyThreadState_Delete(state->newState); + delete state; } - _wxPyNestCount -= 1; #endif } -//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject); @@ -329,9 +445,9 @@ wxPyCallback::wxPyCallback(const wxPyCallback& other) { } wxPyCallback::~wxPyCallback() { - bool doSave = wxPyRestoreThread(); + wxPyTState* state = wxPyBeginBlockThreads(); Py_DECREF(m_func); - wxPySaveThread(doSave); + wxPyEndBlockThreads(state); } @@ -345,7 +461,7 @@ void wxPyCallback::EventThunker(wxEvent& event) { PyObject* tuple; - bool doSave = wxPyRestoreThread(); + wxPyTState* state = wxPyBeginBlockThreads(); wxString className = event.GetClassInfo()->GetClassName(); if (className == "wxPyEvent") @@ -361,33 +477,16 @@ void wxPyCallback::EventThunker(wxEvent& event) { Py_DECREF(tuple); if (result) { Py_DECREF(result); - PyErr_Clear(); + PyErr_Clear(); // Just in case... } else { PyErr_Print(); } - wxPySaveThread(doSave); + wxPyEndBlockThreads(state); } //---------------------------------------------------------------------- -wxPyCallbackHelper::wxPyCallbackHelper() { - m_class = NULL; - m_self = NULL; - m_lastFound = NULL; - m_incRef = FALSE; -} - - -wxPyCallbackHelper::~wxPyCallbackHelper() { - bool doSave = wxPyRestoreThread(); - if (m_incRef) { - Py_XDECREF(m_self); - Py_XDECREF(m_class); - } - wxPySaveThread(doSave); -} - wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) { m_lastFound = NULL; m_self = other.m_self; @@ -399,9 +498,9 @@ wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) { } -void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* _class, int incref) { +void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* klass, int incref) { m_self = self; - m_class = _class; + m_class = klass; m_incRef = incref; if (incref) { Py_INCREF(m_self); @@ -413,12 +512,12 @@ void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* _class, int incref) { // 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. -bool wxPyCallbackHelper::findCallback(const wxString& name) const { +bool wxPyCallbackHelper::findCallback(const char* name) const { wxPyCallbackHelper* self = (wxPyCallbackHelper*)this; // cast away const self->m_lastFound = NULL; - if (m_self && PyObject_HasAttrString(m_self, (char*)name.c_str())) { + if (m_self && PyObject_HasAttrString(m_self, (char*)name)) { PyObject* method; - method = PyObject_GetAttrString(m_self, (char*)name.c_str()); + method = PyObject_GetAttrString(m_self, (char*)name); if (PyMethod_Check(method) && ((PyMethod_GET_CLASS(method) == m_class) || @@ -426,6 +525,9 @@ bool wxPyCallbackHelper::findCallback(const wxString& name) const { self->m_lastFound = method; } + else { + Py_DECREF(method); + } } return m_lastFound != NULL; } @@ -447,10 +549,16 @@ int wxPyCallbackHelper::callCallback(PyObject* argTuple) const { // Invoke the Python callable object, returning the raw PyObject return // value. Caller should DECREF the return value and also call PyEval_SaveThread. PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const { - PyObject* result; + PyObject* result; + + // Save a copy of the pointer in case the callback generates another + // callback. In that case m_lastFound will have a different value when + // it gets back here... + PyObject* method = m_lastFound; - result = PyEval_CallObject(m_lastFound, argTuple); + result = PyEval_CallObject(method, argTuple); Py_DECREF(argTuple); + Py_DECREF(method); if (!result) { PyErr_Print(); } @@ -458,10 +566,35 @@ PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const { } +void wxPyCBH_setCallbackInfo(wxPyCallbackHelper& cbh, PyObject* self, PyObject* klass, int incref) { + cbh.setSelf(self, klass, incref); +} + +bool wxPyCBH_findCallback(const wxPyCallbackHelper& cbh, const char* name) { + return cbh.findCallback(name); +} + +int wxPyCBH_callCallback(const wxPyCallbackHelper& cbh, PyObject* argTuple) { + return cbh.callCallback(argTuple); +} + +PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTuple) { + return cbh.callCallbackObj(argTuple); +} + + +void wxPyCBH_delete(wxPyCallbackHelper* cbh) { + if (cbh->m_incRef) { + wxPyTState* state = wxPyBeginBlockThreads(); + Py_XDECREF(cbh->m_self); + Py_XDECREF(cbh->m_class); + wxPyEndBlockThreads(state); + } +} //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- -// 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. @@ -473,14 +606,14 @@ wxPyEvtSelfRef::wxPyEvtSelfRef() { } wxPyEvtSelfRef::~wxPyEvtSelfRef() { - bool doSave = wxPyRestoreThread(); + wxPyTState* state = wxPyBeginBlockThreads(); if (m_cloned) Py_DECREF(m_self); - wxPySaveThread(doSave); + wxPyEndBlockThreads(state); } void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) { - bool doSave = wxPyRestoreThread(); + wxPyTState* state = wxPyBeginBlockThreads(); if (m_cloned) Py_DECREF(m_self); m_self = self; @@ -488,7 +621,7 @@ void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) { Py_INCREF(m_self); m_cloned = TRUE; } - wxPySaveThread(doSave); + wxPyEndBlockThreads(state); } PyObject* wxPyEvtSelfRef::GetSelf() const { @@ -497,37 +630,41 @@ 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() { +} + @@ -541,26 +678,32 @@ wxPyTimer::wxPyTimer(PyObject* callback) { } wxPyTimer::~wxPyTimer() { - bool doSave = wxPyRestoreThread(); + wxPyTState* state = wxPyBeginBlockThreads(); Py_DECREF(func); - wxPySaveThread(doSave); + wxPyEndBlockThreads(state); } void wxPyTimer::Notify() { - bool doSave = wxPyRestoreThread(); - - PyObject* result; - PyObject* args = Py_BuildValue("()"); + if (!func || func == Py_None) { + wxTimer::Notify(); + } + else { + wxPyTState* state = wxPyBeginBlockThreads(); + + PyObject* result; + PyObject* args = Py_BuildValue("()"); + + result = PyEval_CallObject(func, args); + Py_DECREF(args); + if (result) { + Py_DECREF(result); + PyErr_Clear(); + } else { + PyErr_Print(); + } - result = PyEval_CallObject(func, args); - Py_DECREF(args); - if (result) { - Py_DECREF(result); - PyErr_Clear(); - } else { - PyErr_Print(); + wxPyEndBlockThreads(state); } - wxPySaveThread(doSave); } @@ -575,15 +718,15 @@ PyObject* wxPy_ConvertList(wxListBase* list, const char* className) { wxObject* wxObj; wxNode* node = list->First(); - bool doSave = wxPyRestoreThread(); + wxPyTState* state = wxPyBeginBlockThreads(); pyList = PyList_New(0); while (node) { wxObj = node->Data(); - pyObj = wxPyConstructObject(wxObj, className); + pyObj = wxPyMake_wxObject(wxObj); //wxPyConstructObject(wxObj, className); PyList_Append(pyList, pyObj); node = node->Next(); } - wxPySaveThread(doSave); + wxPyEndBlockThreads(state); return pyList; } @@ -702,43 +845,116 @@ char** string_LIST_helper(PyObject* source) { return temp; } +//-------------------------------- +// Part of patch from Tim Hochberg +static inline bool wxPointFromObjects(PyObject* o1, PyObject* o2, wxPoint* point) { + if (PyInt_Check(o1) && PyInt_Check(o2)) { + point->x = PyInt_AS_LONG(o1); + point->y = PyInt_AS_LONG(o2); + return true; + } + if (PyFloat_Check(o1) && PyFloat_Check(o2)) { + point->x = (int)PyFloat_AS_DOUBLE(o1); + point->y = (int)PyFloat_AS_DOUBLE(o2); + return true; + } + if (PyInstance_Check(o1) || PyInstance_Check(o2)) { + // Disallow instances because they can cause havok + return false; + } + if (PyNumber_Check(o1) && PyNumber_Check(o2)) { + // I believe this excludes instances, so this should be safe without INCREFFing o1 and o2 + point->x = PyInt_AsLong(o1); + point->y = PyInt_AsLong(o2); + return true; + } + return false; +} -wxPoint* wxPoint_LIST_helper(PyObject* source) { - if (!PyList_Check(source)) { - PyErr_SetString(PyExc_TypeError, "Expected a list object."); - return NULL; +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; + bool isFast = PyList_Check(source) || PyTuple_Check(source); + + if (!PySequence_Check(source)) { + goto error0; } - int count = PyList_Size(source); - wxPoint* temp = new wxPoint[count]; - if (! temp) { + + // The length of the sequence is returned in count. + *count = PySequence_Length(source); + if (*count < 0) { + goto error0; + } + + temp = new wxPoint[*count]; + if (!temp) { PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array"); return NULL; } - for (int x=0; x= 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; } @@ -820,10 +1049,7 @@ wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) { PyObject* o1 = PyTuple_GetItem(o, 0); PyObject* o2 = PyTuple_GetItem(o, 1); PyObject* o3 = PyTuple_GetItem(o, 2); - - temp[x].m_flags = PyInt_AsLong(o1); - temp[x].m_keyCode = PyInt_AsLong(o2); - temp[x].m_command = PyInt_AsLong(o3); + temp[x].Set(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3)); } else { PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects."); @@ -834,6 +1060,99 @@ wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) { } +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