X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0adbc1660ee4c4526a9011cb9347cb668c41ec3e..32b70aec1ff90877ae0ce2ce82967f698218fbdc:/wxPython/src/helpers.cpp diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp index dbca54d691..c3c52d2a6e 100644 --- a/wxPython/src/helpers.cpp +++ b/wxPython/src/helpers.cpp @@ -15,14 +15,12 @@ #undef DEBUG #include #include "helpers.h" +#include "pyistream.h" #ifdef __WXMSW__ #include -#undef FindWindow -#undef GetCharWidth -#undef LoadAccelerators -#undef GetClassInfo -#undef GetClassName +#include +#include #endif #ifdef __WXGTK__ @@ -32,6 +30,42 @@ #endif +//---------------------------------------------------------------------- + +#if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE +#error Python must support Unicode to use wxWindows Unicode +#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_DECLARE_OBJARRAY(wxPyThreadState, wxPyThreadStateArray); +#include +WX_DEFINE_OBJARRAY(wxPyThreadStateArray); + +wxPyThreadStateArray* wxPyTStates = NULL; +wxMutex* wxPyTMutex = NULL; +#endif #ifdef __WXMSW__ // If building for win32... @@ -51,11 +85,9 @@ BOOL WINAPI DllMain( #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"); @@ -67,44 +99,69 @@ wxPyApp::~wxPyApp() { // 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 +static char* wxPyCopyCString(const wxChar* src) +{ + wxWX2MBbuf buff = (wxWX2MBbuf)wxConvCurrent->cWX2MB(src); + size_t len = strlen(buff); + char* dest = new char[len+1]; + strcpy(dest, buff); + return dest; +} -int WXDLLEXPORT wxEntryStart( int argc, char** argv ); -int WXDLLEXPORT wxEntryInitGui(); -void WXDLLEXPORT wxEntryCleanup(); +#if wxUSE_UNICODE +static char* wxPyCopyCString(const char* src) // we need a char version too +{ + size_t len = strlen(src); + char* dest = new char[len+1]; + strcpy(dest, src); + return dest; +} +#endif +static wxChar* wxPyCopyWString(const char *src) +{ + //wxMB2WXbuf buff = wxConvCurrent->cMB2WX(src); + wxString str(src, *wxConvCurrent); + return copystring(str); +} -#ifdef WXP_WITH_THREAD -PyThreadState* wxPyEventThreadState = NULL; +#if wxUSE_UNICODE +static wxChar* wxPyCopyWString(const wxChar *src) +{ + return copystring(src); +} #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 // wxcmodule is imported. (Before there is a wxApp object.) @@ -117,7 +174,8 @@ void __wxPreStart() #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 @@ -134,8 +192,15 @@ void __wxPreStart() argc = PyList_Size(sysargv); argv = new char*[argc+1]; int x; - for(x=0; xargc = argc; wxPythonApp->argv = argv; @@ -205,8 +278,16 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args) return Py_None; } + void __wxCleanup() { wxEntryCleanup(); +#ifdef WXP_WITH_THREAD + delete wxPyTMutex; + wxPyTMutex = NULL; + wxPyTStates->Empty(); + delete wxPyTStates; + wxPyTStates = NULL; +#endif } @@ -214,6 +295,7 @@ void __wxCleanup() { static PyObject* wxPython_dict = NULL; static PyObject* wxPyPtrTypeMap = NULL; + PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) { @@ -233,8 +315,8 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) #ifdef __WXMOTIF__ #define wxPlatform "__WXMOTIF__" #endif -#ifdef __WXQT__ -#define wxPlatform "__WXQT__" +#ifdef __WXX11__ +#define wxPlatform "__WXX11__" #endif #ifdef __WXGTK__ #define wxPlatform "__WXGTK__" @@ -247,11 +329,58 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) #endif PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform)); + PyDict_SetItemString(wxPython_dict, "wxUSE_UNICODE", PyInt_FromLong(wxUSE_UNICODE)); Py_INCREF(Py_None); return Py_None; } +//--------------------------------------------------------------------------- + +void wxPyClientData_dtor(wxPyClientData* self) { + wxPyBeginBlockThreads(); + Py_DECREF(self->m_obj); + wxPyEndBlockThreads(); +} + +void wxPyUserData_dtor(wxPyUserData* self) { + wxPyBeginBlockThreads(); + Py_DECREF(self->m_obj); + wxPyEndBlockThreads(); +} + + +// This is called when an OOR controled object is being destroyed. Although +// the C++ object is going away there is no way to force the Python object +// (and all references to it) to die too. This causes problems (crashes) in +// wxPython when a python shadow object attempts to call a C++ method using +// the now bogus pointer... So to try and prevent this we'll do a little black +// magic and change the class of the python instance to a class that will +// raise an exception for any attempt to call methods with it. See +// _wxPyDeadObject in _extras.py for the implementation of this class. +void wxPyOORClientData_dtor(wxPyOORClientData* self) { + + static PyObject* deadObjectClass = NULL; + + wxPyBeginBlockThreads(); + if (deadObjectClass == NULL) { + deadObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyDeadObject"); + wxASSERT_MSG(deadObjectClass != NULL, wxT("Can't get _wxPyDeadObject class!")); + Py_INCREF(deadObjectClass); + } + + // Clear the instance's dictionary, put the name of the old class into the + // instance, and then reset the class to be the dead class. + if (self->m_obj->ob_refcnt > 1) { // but only if there is more than one reference + wxASSERT_MSG(PyInstance_Check(self->m_obj), wxT("m_obj not an instance!?!?!")); + PyInstanceObject* inst = (PyInstanceObject*)self->m_obj; + PyDict_Clear(inst->in_dict); + PyDict_SetItemString(inst->in_dict, "_name", inst->in_class->cl_name); + inst->in_class = (PyClassObject*)deadObjectClass; + Py_INCREF(deadObjectClass); + } + wxPyEndBlockThreads(); +} //--------------------------------------------------------------------------- // Stuff used by OOR to find the right wxPython class type to return and to @@ -262,10 +391,10 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) // 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. +// (See __wxSetDictionary) void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) { if (! wxPyPtrTypeMap) wxPyPtrTypeMap = PyDict_New(); - PyDict_SetItemString(wxPyPtrTypeMap, (char*)commonName, PyString_FromString((char*)ptrName)); @@ -273,39 +402,59 @@ void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) { -PyObject* wxPyClassExists(const char* className) { +PyObject* wxPyClassExists(const wxString& className) { if (!className) return NULL; char buff[64]; // should always be big enough... - sprintf(buff, "%sPtr", className); + sprintf(buff, "%sPtr", className.mbc_str()); PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff); return classobj; // returns NULL if not found } -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; + wxPyOORClientData* data = (wxPyOORClientData*)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 wxPyOORClientData(target)); + } else { + wxString msg(wxT("wxPython class not found for ")); + msg += source->GetClassInfo()->GetClassName(); + PyErr_SetString(PyExc_NameError, msg.mbc_str()); + target = NULL; + } } } else { // source was NULL so return None. Py_INCREF(Py_None); target = Py_None; @@ -313,23 +462,49 @@ PyObject* wxPyMake_wxObject(wxObject* source) { 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; + wxPyOORClientData* data = (wxPyOORClientData*)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 wxPyOORClientData(target)); + } + return target; +} + + + //--------------------------------------------------------------------------- PyObject* wxPyConstructObject(void* ptr, - const char* className, + const wxString& className, PyObject* klass, int setThisOwn) { PyObject* obj; PyObject* arg; PyObject* item; + wxString name(className); char swigptr[64]; // should always be big enough... char buff[64]; - if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)className)) != NULL) { - className = PyString_AsString(item); + if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)(const char*)name.mbc_str())) != NULL) { + name = wxString(PyString_AsString(item), *wxConvCurrent); } - sprintf(buff, "_%s_p", className); + sprintf(buff, "_%s_p", (const char*)name.mbc_str()); SWIG_MakePtr(swigptr, ptr, buff); arg = Py_BuildValue("(s)", swigptr); @@ -347,7 +522,7 @@ PyObject* wxPyConstructObject(void* ptr, PyObject* wxPyConstructObject(void* ptr, - const char* className, + const wxString& className, int setThisOwn) { PyObject* obj; @@ -357,8 +532,10 @@ PyObject* wxPyConstructObject(void* ptr, } char buff[64]; // should always be big enough... + sprintf(buff, "%sPtr", (const char*)className.mbc_str()); + + wxASSERT_MSG(wxPython_dict, wxT("wxPython_dict is not set yet!!")); - sprintf(buff, "%sPtr", className); PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff); if (! classobj) { char temp[128]; @@ -372,46 +549,363 @@ PyObject* wxPyConstructObject(void* ptr, return wxPyConstructObject(ptr, className, classobj, setThisOwn); } + //--------------------------------------------------------------------------- -static PyThreadState* myPyThreadState_Get() { - PyThreadState* current; - current = PyThreadState_Swap(NULL); - PyThreadState_Swap(current); - return current; + +#ifdef WXP_WITH_THREAD +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, wxT("PyThreadState should not be NULL!")); + return tstate; +} -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 +void wxPySaveThreadState(PyThreadState* tstate) { + if (wxPyTMutex == NULL) { // Python is shutting down, assume a single thread... + gs_shutdownTState = tstate; + return; } - else + 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 FALSE; } +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 wxPySaveThread(bool doSave) { +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 } + //--------------------------------------------------------------------------- +// wxPyInputStream and wxPyCBInputStream methods + + +void wxPyInputStream::close() { + /* do nothing for now */ +} + +void wxPyInputStream::flush() { + /* do nothing for now */ +} + +bool wxPyInputStream::eof() { + if (m_wxis) + return m_wxis->Eof(); + else + return TRUE; +} + +wxPyInputStream::~wxPyInputStream() { + /* do nothing */ +} + + + + +PyObject* wxPyInputStream::read(int size) { + PyObject* obj = NULL; + wxMemoryBuffer buf; + const int BUFSIZE = 1024; + + // check if we have a real wxInputStream to work with + if (!m_wxis) { + PyErr_SetString(PyExc_IOError, "no valid C-wxInputStream"); + return NULL; + } + + if (size < 0) { + // read until EOF + while (! m_wxis->Eof()) { + m_wxis->Read(buf.GetAppendBuf(BUFSIZE), BUFSIZE); + buf.UngetAppendBuf(m_wxis->LastRead()); + } + + } else { // Read only size number of characters + m_wxis->Read(buf.GetWriteBuf(size), size); + buf.UngetWriteBuf(m_wxis->LastRead()); + } + + // error check + if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { + PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); + } + else { + // We use only strings for the streams, not unicode + obj = PyString_FromStringAndSize(buf, buf.GetDataLen()); + } + return obj; +} + + +PyObject* wxPyInputStream::readline(int size) { + PyObject* obj = NULL; + wxMemoryBuffer buf; + int i; + char ch; + + // check if we have a real wxInputStream to work with + if (!m_wxis) { + PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream"); + return NULL; + } + + // read until \n or byte limit reached + for (i=ch=0; (ch != '\n') && (!m_wxis->Eof()) && ((size < 0) || (i < size)); i++) { + ch = m_wxis->GetC(); + buf.AppendByte(ch); + } + + // errorcheck + if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { + PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); + } + else { + // We use only strings for the streams, not unicode + obj = PyString_FromStringAndSize((char*)buf.GetData(), buf.GetDataLen()); + } + return obj; +} + + +PyObject* wxPyInputStream::readlines(int sizehint) { + PyObject* pylist; + + // check if we have a real wxInputStream to work with + if (!m_wxis) { + PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream below"); + return NULL; + } + + // init list + pylist = PyList_New(0); + if (!pylist) { + PyErr_NoMemory(); + return NULL; + } + + // read sizehint bytes or until EOF + int i; + for (i=0; (!m_wxis->Eof()) && ((sizehint < 0) || (i < sizehint));) { + PyObject* s = this->readline(); + if (s == NULL) { + Py_DECREF(pylist); + return NULL; + } + PyList_Append(pylist, s); + i += PyString_Size(s); + } + + // error check + if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { + Py_DECREF(pylist); + PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); + return NULL; + } + + return pylist; +} +void wxPyInputStream::seek(int offset, int whence) { + if (m_wxis) + m_wxis->SeekI(offset, wxSeekMode(whence)); +} + +int wxPyInputStream::tell(){ + if (m_wxis) + return m_wxis->TellI(); + else return 0; +} + + + + +wxPyCBInputStream::wxPyCBInputStream(PyObject *r, PyObject *s, PyObject *t, bool block) + : wxInputStream(), m_read(r), m_seek(s), m_tell(t), m_block(block) +{} + + +wxPyCBInputStream::~wxPyCBInputStream() { + if (m_block) wxPyBeginBlockThreads(); + Py_XDECREF(m_read); + Py_XDECREF(m_seek); + Py_XDECREF(m_tell); + if (m_block) wxPyEndBlockThreads(); +} + + +wxPyCBInputStream* wxPyCBInputStream::create(PyObject *py, bool block) { + if (block) wxPyBeginBlockThreads(); + + PyObject* read = getMethod(py, "read"); + PyObject* seek = getMethod(py, "seek"); + PyObject* tell = getMethod(py, "tell"); + + if (!read) { + PyErr_SetString(PyExc_TypeError, "Not a file-like object"); + Py_XDECREF(read); + Py_XDECREF(seek); + Py_XDECREF(tell); + if (block) wxPyEndBlockThreads(); + return NULL; + } + + if (block) wxPyEndBlockThreads(); + return new wxPyCBInputStream(read, seek, tell, block); +} + +PyObject* wxPyCBInputStream::getMethod(PyObject* py, char* name) { + if (!PyObject_HasAttrString(py, name)) + return NULL; + PyObject* o = PyObject_GetAttrString(py, name); + if (!PyMethod_Check(o) && !PyCFunction_Check(o)) { + Py_DECREF(o); + return NULL; + } + return o; +} + + +size_t wxPyCBInputStream::GetSize() const { + wxPyCBInputStream* self = (wxPyCBInputStream*)this; // cast off const + if (m_seek && m_tell) { + off_t temp = self->OnSysTell(); + off_t ret = self->OnSysSeek(0, wxFromEnd); + self->OnSysSeek(temp, wxFromStart); + return ret; + } + else + return 0; +} + + +size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) { + if (bufsize == 0) + return 0; + + wxPyBeginBlockThreads(); + PyObject* arglist = Py_BuildValue("(i)", bufsize); + PyObject* result = PyEval_CallObject(m_read, arglist); + Py_DECREF(arglist); + + size_t o = 0; + if ((result != NULL) && PyString_Check(result)) { + o = PyString_Size(result); + if (o == 0) + m_lasterror = wxSTREAM_EOF; + if (o > bufsize) + o = bufsize; + memcpy((char*)buffer, PyString_AsString(result), o); // strings only, not unicode... + Py_DECREF(result); + + } + else + m_lasterror = wxSTREAM_READ_ERROR; + wxPyEndBlockThreads(); + m_lastcount = o; + return o; +} + +size_t wxPyCBInputStream::OnSysWrite(const void *buffer, size_t bufsize) { + m_lasterror = wxSTREAM_WRITE_ERROR; + return 0; +} + +off_t wxPyCBInputStream::OnSysSeek(off_t off, wxSeekMode mode) { + wxPyBeginBlockThreads(); + PyObject* arglist = Py_BuildValue("(ii)", off, mode); + PyObject* result = PyEval_CallObject(m_seek, arglist); + Py_DECREF(arglist); + Py_XDECREF(result); + wxPyEndBlockThreads(); + return OnSysTell(); +} + +off_t wxPyCBInputStream::OnSysTell() const { + wxPyBeginBlockThreads(); + PyObject* arglist = Py_BuildValue("()"); + PyObject* result = PyEval_CallObject(m_tell, arglist); + Py_DECREF(arglist); + off_t o = 0; + if (result != NULL) { + o = PyInt_AsLong(result); + Py_DECREF(result); + }; + wxPyEndBlockThreads(); + return o; +} + +//---------------------------------------------------------------------- + IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject); wxPyCallback::wxPyCallback(PyObject* func) { @@ -425,9 +919,9 @@ wxPyCallback::wxPyCallback(const wxPyCallback& other) { } wxPyCallback::~wxPyCallback() { - bool doSave = wxPyRestoreThread(); + wxPyBeginBlockThreads(); Py_DECREF(m_func); - wxPySaveThread(doSave); + wxPyEndBlockThreads(); } @@ -441,15 +935,16 @@ void wxPyCallback::EventThunker(wxEvent& event) { PyObject* tuple; - bool doSave = wxPyRestoreThread(); + wxPyBeginBlockThreads(); wxString className = event.GetClassInfo()->GetClassName(); if (className == "wxPyEvent") arg = ((wxPyEvent*)&event)->GetSelf(); else if (className == "wxPyCommandEvent") arg = ((wxPyCommandEvent*)&event)->GetSelf(); - else + else { arg = wxPyConstructObject((void*)&event, className); + } tuple = PyTuple_New(1); PyTuple_SET_ITEM(tuple, 0, arg); @@ -461,7 +956,7 @@ void wxPyCallback::EventThunker(wxEvent& event) { } else { PyErr_Print(); } - wxPySaveThread(doSave); + wxPyEndBlockThreads(); } @@ -489,20 +984,102 @@ void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* klass, 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. +#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 it 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 actually 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; + } + 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 { @@ -546,7 +1123,7 @@ PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const { } -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); } @@ -564,17 +1141,17 @@ PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTu 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. @@ -586,14 +1163,14 @@ wxPyEvtSelfRef::wxPyEvtSelfRef() { } 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; @@ -601,7 +1178,7 @@ void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) { Py_INCREF(m_self); m_cloned = TRUE; } - wxPySaveThread(doSave); + wxPyEndBlockThreads(); } PyObject* wxPyEvtSelfRef::GetSelf() const { @@ -610,37 +1187,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() { +} + @@ -654,9 +1235,9 @@ wxPyTimer::wxPyTimer(PyObject* callback) { } wxPyTimer::~wxPyTimer() { - bool doSave = wxPyRestoreThread(); + wxPyBeginBlockThreads(); Py_DECREF(func); - wxPySaveThread(doSave); + wxPyEndBlockThreads(); } void wxPyTimer::Notify() { @@ -664,7 +1245,7 @@ void wxPyTimer::Notify() { wxTimer::Notify(); } else { - bool doSave = wxPyRestoreThread(); + wxPyBeginBlockThreads(); PyObject* result; PyObject* args = Py_BuildValue("()"); @@ -678,7 +1259,7 @@ void wxPyTimer::Notify() { PyErr_Print(); } - wxPySaveThread(doSave); + wxPyEndBlockThreads(); } } @@ -694,7 +1275,7 @@ PyObject* wxPy_ConvertList(wxListBase* list, const char* className) { wxObject* wxObj; wxNode* node = list->First(); - bool doSave = wxPyRestoreThread(); + wxPyBeginBlockThreads(); pyList = PyList_New(0); while (node) { wxObj = node->Data(); @@ -702,7 +1283,7 @@ PyObject* wxPy_ConvertList(wxListBase* list, const char* className) { PyList_Append(pyList, pyObj); node = node->Next(); } - wxPySaveThread(doSave); + wxPyEndBlockThreads(); return pyList; } @@ -727,7 +1308,108 @@ long wxPyGetWinHandle(wxWindow* win) { //---------------------------------------------------------------------- // Some helper functions for typemaps in my_typemaps.i, so they won't be -// included in every file... +// included in every file over and over again... + +#if PYTHON_API_VERSION >= 1009 + static char* wxStringErrorMsg = "String or Unicode type required"; +#else + static char* wxStringErrorMsg = "String type required"; +#endif + + +wxString* wxString_in_helper(PyObject* source) { + wxString* target; +#if PYTHON_API_VERSION >= 1009 // Have Python unicode API + if (!PyString_Check(source) && !PyUnicode_Check(source)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } +#if wxUSE_UNICODE + if (PyUnicode_Check(source)) { + target = new wxString(PyUnicode_AS_UNICODE(source)); + } else { + // It is a string, get pointers to it and transform to unicode + char* tmpPtr; int tmpSize; + PyString_AsStringAndSize(source, &tmpPtr, &tmpSize); + target = new wxString(tmpPtr, *wxConvCurrent, tmpSize); + } +#else + char* tmpPtr; int tmpSize; + if (PyString_AsStringAndSize(source, &tmpPtr, &tmpSize) == -1) { + PyErr_SetString(PyExc_TypeError, "Unable to convert string"); + return NULL; + } + target = new wxString(tmpPtr, tmpSize); +#endif // wxUSE_UNICODE + +#else // No Python unicode API (1.5.2) + if (!PyString_Check(source)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + target = new wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source)); +#endif + return target; +} + + +// Similar to above except doesn't use "new" and doesn't set an exception +wxString Py2wxString(PyObject* source) +{ + wxString target; + bool doDecRef = FALSE; + +#if PYTHON_API_VERSION >= 1009 // Have Python unicode API + if (!PyString_Check(source) && !PyUnicode_Check(source)) { + // Convert to String if not one already... (TODO: Unicode too?) + source = PyObject_Str(source); + doDecRef = TRUE; + } + +#if wxUSE_UNICODE + if (PyUnicode_Check(source)) { + target = PyUnicode_AS_UNICODE(source); + } else { + // It is a string, get pointers to it and transform to unicode + char* tmpPtr; int tmpSize; + PyString_AsStringAndSize(source, &tmpPtr, &tmpSize); + target = wxString(tmpPtr, *wxConvCurrent, tmpSize); + } +#else + char* tmpPtr; int tmpSize; + PyString_AsStringAndSize(source, &tmpPtr, &tmpSize); + target = wxString(tmpPtr, tmpSize); +#endif // wxUSE_UNICODE + +#else // No Python unicode API (1.5.2) + if (!PyString_Check(source)) { + // Convert to String if not one already... + source = PyObject_Str(source); + doDecRef = TRUE; + } + target = wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source)); +#endif + + if (doDecRef) + Py_DECREF(source); + return target; +} + + +// Make either a Python String or Unicode object, depending on build mode +PyObject* wx2PyString(const wxString& src) +{ + PyObject* str; +#if wxUSE_UNICODE + str = PyUnicode_FromUnicode(src.c_str(), src.Len()); +#else + str = PyString_FromStringAndSize(src.c_str(), src.Len()); +#endif + return str; +} + + +//---------------------------------------------------------------------- byte* byte_LIST_helper(PyObject* source) { @@ -848,23 +1530,19 @@ static inline bool wxPointFromObjects(PyObject* o1, PyObject* o2, wxPoint* point } -#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; @@ -981,11 +1659,21 @@ wxString* wxString_LIST_helper(PyObject* source) { } 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; + } +#else if (! PyString_Check(o)) { PyErr_SetString(PyExc_TypeError, "Expected a list of strings."); return NULL; } - temp[x] = PyString_AsString(o); +#endif + + wxString* pStr = wxString_in_helper(o); + temp[x] = *pStr; + delete pStr; } return temp; } @@ -1027,6 +1715,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