X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f74ff5efa5604fcde3cc5ba9009cb015a6f388cf..e37741247336250f4460714baa43b8136cee3b96:/wxPython/src/helpers.cpp diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp index 065e70e0ba..c47bd837c5 100644 --- a/wxPython/src/helpers.cpp +++ b/wxPython/src/helpers.cpp @@ -10,11 +10,11 @@ // Licence: wxWindows license ///////////////////////////////////////////////////////////////////////////// -#include // get the correct definition of NULL #undef DEBUG #include #include "helpers.h" +#include "pyistream.h" #ifdef __WXMSW__ #include @@ -28,6 +28,11 @@ #include #endif +//---------------------------------------------------------------------- + +#if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE +#error Python must support Unicode to use wxWindows Unicode +#endif //---------------------------------------------------------------------- @@ -40,6 +45,8 @@ int WXDLLEXPORT wxEntryInitGui(); void WXDLLEXPORT wxEntryCleanup(); wxPyApp* wxPythonApp = NULL; // Global instance of application object +bool wxPyDoCleanup = FALSE; +bool wxPyDoingCleanup = FALSE; #ifdef WXP_WITH_THREAD @@ -61,6 +68,11 @@ wxMutex* wxPyTMutex = NULL; #endif +static PyObject* wxPython_dict = NULL; +static PyObject* wxPyPtrTypeMap = NULL; +static PyObject* wxPyAssertionError = NULL; + + #ifdef __WXMSW__ // If building for win32... //---------------------------------------------------------------------- // This gets run when the DLL is loaded. We just need to save a handle. @@ -72,8 +84,11 @@ BOOL WINAPI DllMain( LPVOID lpvReserved // reserved ) { - wxSetInstance(hinstDLL); - return 1; + // If wxPython is embedded in another wxWindows app then + // the inatance has already been set. + if (! wxGetInstance()) + wxSetInstance(hinstDLL); + return TRUE; } #endif @@ -81,17 +96,19 @@ BOOL WINAPI DllMain( // Classes for implementing the wxp main application shell. //---------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxPyApp, wxApp); + wxPyApp::wxPyApp() { -// printf("**** ctor\n"); + m_assertMode = wxPYAPP_ASSERT_EXCEPTION; } + wxPyApp::~wxPyApp() { -// printf("**** dtor\n"); } -// This one isn't acutally called... See __wxStart() +// This one isn't acutally called... We fake it with __wxStart() bool wxPyApp::OnInit() { return FALSE; } @@ -107,6 +124,10 @@ int wxPyApp::MainLoop() { #endif if (initialized) { + if ( m_exitOnFrameDelete == Later ) { + m_exitOnFrameDelete = Yes; + } + retval = wxApp::MainLoop(); OnExit(); } @@ -114,15 +135,245 @@ int wxPyApp::MainLoop() { } +bool wxPyApp::OnInitGui() { + bool rval=TRUE; + wxApp::OnInitGui(); // in this case always call the base class version + // wxPyBeginBlockThreads(); *** only called from within __wxStart so we already have the GIL + if (wxPyCBH_findCallback(m_myInst, "OnInitGui")) + rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); + // wxPyEndBlockThreads(); *** + return rval; +} + + +int wxPyApp::OnExit() { + int rval=0; + wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "OnExit")) + rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); + wxPyEndBlockThreads(); + wxApp::OnExit(); // in this case always call the base class version + return rval; +} + + +#ifdef __WXDEBUG__ +void wxPyApp::OnAssert(const wxChar *file, + int line, + const wxChar *cond, + const wxChar *msg) { + + // If the OnAssert is overloaded in the Python class then call it... + bool found; + wxPyBeginBlockThreads(); + if ((found = wxPyCBH_findCallback(m_myInst, "OnAssert"))) { + PyObject* fso = wx2PyString(file); + PyObject* cso = wx2PyString(file); + PyObject* mso; + if (msg != NULL) + mso = wx2PyString(file); + else { + mso = Py_None; Py_INCREF(Py_None); + } + wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiOO)", fso, line, cso, mso)); + Py_DECREF(fso); + Py_DECREF(cso); + Py_DECREF(mso); + } + wxPyEndBlockThreads(); + + // ...otherwise do our own thing with it + if (! found) { + // ignore it? + if (m_assertMode & wxPYAPP_ASSERT_SUPPRESS) + return; + + // turn it into a Python exception? + if (m_assertMode & wxPYAPP_ASSERT_EXCEPTION) { + wxString buf; + buf.Alloc(4096); + buf.Printf(wxT("C++ assertion \"%s\" failed in %s(%d)"), cond, file, line); + if (msg != NULL) { + buf += wxT(": "); + buf += msg; + } + + // set the exception + wxPyBeginBlockThreads(); + PyObject* s = wx2PyString(buf); + PyErr_SetObject(wxPyAssertionError, s); + Py_DECREF(s); + wxPyEndBlockThreads(); + + // Now when control returns to whatever API wrapper was called from + // Python it should detect that an exception is set and will return + // NULL, signalling the exception to Python. + } + + // Send it to the normal log destination, but only if + // not _DIALOG because it will call this too + if ( (m_assertMode & wxPYAPP_ASSERT_LOG) && !(m_assertMode & wxPYAPP_ASSERT_DIALOG)) { + wxString buf; + buf.Alloc(4096); + buf.Printf(wxT("%s(%d): assert \"%s\" failed"), + file, line, cond); + if (msg != NULL) { + buf += wxT(": "); + buf += msg; + } + wxLogDebug(buf); + } + + // do the normal wx assert dialog? + if (m_assertMode & wxPYAPP_ASSERT_DIALOG) + wxApp::OnAssert(file, line, cond, msg); + } +} +#endif + + +/*static*/ +bool wxPyApp::GetMacDefaultEncodingIsPC() { +#ifdef __WXMAC__ + return s_macDefaultEncodingIsPC; +#else + return 0; +#endif +} + +/*static*/ +bool wxPyApp::GetMacSupportPCMenuShortcuts() { +#ifdef __WXMAC__ + return s_macSupportPCMenuShortcuts; +#else + return 0; +#endif +} + +/*static*/ +long wxPyApp::GetMacAboutMenuItemId() { +#ifdef __WXMAC__ + return s_macAboutMenuItemId; +#else + return 0; +#endif +} + +/*static*/ +long wxPyApp::GetMacPreferencesMenuItemId() { +#ifdef __WXMAC__ + return s_macPreferencesMenuItemId; +#else + return 0; +#endif +} + +/*static*/ +long wxPyApp::GetMacExitMenuItemId() { +#ifdef __WXMAC__ + return s_macExitMenuItemId; +#else + return 0; +#endif +} + +/*static*/ +wxString wxPyApp::GetMacHelpMenuTitleName() { +#ifdef __WXMAC__ + return s_macHelpMenuTitleName; +#else + return wxEmptyString; +#endif +} + +/*static*/ +void wxPyApp::SetMacDefaultEncodingIsPC(bool val) { +#ifdef __WXMAC__ + s_macDefaultEncodingIsPC = val; +#endif +} + +/*static*/ +void wxPyApp::SetMacSupportPCMenuShortcuts(bool val) { +#ifdef __WXMAC__ + s_macSupportPCMenuShortcuts = val; +#endif +} + +/*static*/ +void wxPyApp::SetMacAboutMenuItemId(long val) { +#ifdef __WXMAC__ + s_macAboutMenuItemId = val; +#endif +} + +/*static*/ +void wxPyApp::SetMacPreferencesMenuItemId(long val) { +#ifdef __WXMAC__ + s_macPreferencesMenuItemId = val; +#endif +} + +/*static*/ +void wxPyApp::SetMacExitMenuItemId(long val) { +#ifdef __WXMAC__ + s_macExitMenuItemId = val; +#endif +} + +/*static*/ +void wxPyApp::SetMacHelpMenuTitleName(const wxString& val) { +#ifdef __WXMAC__ + s_macHelpMenuTitleName = val; +#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; +} + +#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); +} + +#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.) -void __wxPreStart() +void __wxPreStart(PyObject* moduleDict) { #ifdef __WXMSW__ @@ -135,12 +386,20 @@ void __wxPreStart() wxPyTMutex = new wxMutex; #endif - // Bail out if there is already windows created. This means that the + wxApp::CheckBuildOptions(wxBuildOptions()); + + wxPyAssertionError = PyErr_NewException("wxPython.wxc.wxPyAssertionError", + PyExc_AssertionError, NULL); + PyDict_SetItemString(moduleDict, "wxPyAssertionError", wxPyAssertionError); + + + // Bail out if there is already a wxApp created. This means that the // toolkit has already been initialized, as in embedding wxPython in - // a C++ wxWindows app. - if (wxTopLevelWindows.Number() > 0) + // a C++ wxWindows app, so we don't need to call wxEntryStart. + if (wxTheApp != NULL) { return; - + } + wxPyDoCleanup = TRUE; int argc = 0; char** argv = NULL; @@ -149,8 +408,10 @@ void __wxPreStart() argc = PyList_Size(sysargv); 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; + wxChar** argv = NULL; PyObject* sysargv = PySys_GetObject("argv"); if (sysargv != NULL) { argc = PyList_Size(sysargv); - argv = new char*[argc+1]; + argv = new wxChar*[argc+1]; int x; - for(x=0; xargc = argc; wxPythonApp->argv = argv; @@ -198,31 +454,42 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args) // Call the Python App's OnInit function arglist = PyTuple_New(0); result = PyEval_CallObject(onInitFunc, arglist); + Py_DECREF(arglist); if (!result) { // an exception was raised. return NULL; } - if (! PyInt_Check(result)) { + PyObject* pyint = PyNumber_Int(result); + if (! pyint) { PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value"); - return NULL; + goto error; } - bResult = PyInt_AS_LONG(result); + bResult = PyInt_AS_LONG(pyint); if (! bResult) { PyErr_SetString(PyExc_SystemExit, "OnInit returned FALSE, exiting..."); - return NULL; + goto error; } #ifdef __WXGTK__ wxTheApp->m_initialized = (wxTopLevelWindows.GetCount() > 0); #endif + Py_DECREF(result); + Py_DECREF(pyint); Py_INCREF(Py_None); return Py_None; + + error: + Py_XDECREF(result); + Py_XDECREF(pyint); + return NULL; } void __wxCleanup() { - wxEntryCleanup(); + wxPyDoingCleanup = TRUE; + if (wxPyDoCleanup) + wxEntryCleanup(); #ifdef WXP_WITH_THREAD delete wxPyTMutex; wxPyTMutex = NULL; @@ -234,8 +501,6 @@ void __wxCleanup() { -static PyObject* wxPython_dict = NULL; -static PyObject* wxPyPtrTypeMap = NULL; PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) { @@ -269,12 +534,73 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) #define wxPlatform "__WXMAC__" #endif +#ifdef __WXDEBUG__ + int wxdebug = 1; +#else + int wxdebug = 0; +#endif + PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform)); + PyDict_SetItemString(wxPython_dict, "wxUSE_UNICODE", PyInt_FromLong(wxUSE_UNICODE)); + PyDict_SetItemString(wxPython_dict, "__WXDEBUG__", PyInt_FromLong(wxdebug)); Py_INCREF(Py_None); return Py_None; } +//--------------------------------------------------------------------------- + +void wxPyClientData_dtor(wxPyClientData* self) { + if (! wxPyDoingCleanup) { // Don't do it during cleanup as Python + // may have already garbage collected the object... + wxPyBeginBlockThreads(); + Py_DECREF(self->m_obj); + wxPyEndBlockThreads(); + } +} + +void wxPyUserData_dtor(wxPyUserData* self) { + if (! wxPyDoingCleanup) { + 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); + } + + // TODO: If wxPyDOingCleanup, should we skip the code below? + + // 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 @@ -285,6 +611,7 @@ 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(); @@ -295,16 +622,28 @@ void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) { -PyObject* wxPyClassExists(const char* className) { +PyObject* wxPyClassExists(const wxString& className) { + + PyObject* item; + wxString name(className); + char buff[64]; // should always be big enough... if (!className) return NULL; - char buff[64]; // should always be big enough... - - sprintf(buff, "%sPtr", className); + // Try the name as-is first + sprintf(buff, "%sPtr", (const char*)name.mbc_str()); PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff); + // if not found see if there is a mapped name for it + if ( ! classobj) { + if ((item = PyDict_GetItemString(wxPyPtrTypeMap, (char*)(const char*)name.mbc_str())) != NULL) { + name = wxString(PyString_AsString(item), *wxConvCurrent); + sprintf(buff, "%sPtr", (const char*)name.mbc_str()); + classobj = PyDict_GetItemString(wxPython_dict, buff); + } + } + return classobj; // returns NULL if not found } @@ -320,7 +659,7 @@ PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) { if (checkEvtHandler && wxIsKindOf(source, wxEvtHandler)) { isEvtHandler = TRUE; wxEvtHandler* eh = (wxEvtHandler*)source; - wxPyClientData* data = (wxPyClientData*)eh->GetClientObject(); + wxPyOORClientData* data = (wxPyOORClientData*)eh->GetClientObject(); if (data) { target = data->m_obj; Py_INCREF(target); @@ -330,8 +669,8 @@ PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) { 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(); + wxClassInfo* info = source->GetClassInfo(); + wxString name = info->GetClassName(); PyObject* klass = wxPyClassExists(name); while (info && !klass) { name = (wxChar*)info->GetBaseClassName1(); @@ -341,11 +680,11 @@ PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) { if (info) { target = wxPyConstructObject(source, name, klass, FALSE); if (target && isEvtHandler) - ((wxEvtHandler*)source)->SetClientObject(new wxPyClientData(target)); + ((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target)); } else { - wxString msg("wxPython class not found for "); + wxString msg(wxT("wxPython class not found for ")); msg += source->GetClassInfo()->GetClassName(); - PyErr_SetString(PyExc_NameError, msg.c_str()); + PyErr_SetString(PyExc_NameError, msg.mbc_str()); target = NULL; } } @@ -364,7 +703,7 @@ PyObject* wxPyMake_wxSizer(wxSizer* source) { // 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(); + wxPyOORClientData* data = (wxPyOORClientData*)sz->GetClientObject(); if (data) { target = data->m_obj; Py_INCREF(target); @@ -373,7 +712,7 @@ PyObject* wxPyMake_wxSizer(wxSizer* source) { if (! target) { target = wxPyMake_wxObject(source, FALSE); if (target != Py_None) - ((wxSizer*)source)->SetClientObject(new wxPyClientData(target)); + ((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target)); } return target; } @@ -383,20 +722,21 @@ PyObject* wxPyMake_wxSizer(wxSizer* source) { //--------------------------------------------------------------------------- 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); @@ -414,33 +754,30 @@ PyObject* wxPyConstructObject(void* ptr, PyObject* wxPyConstructObject(void* ptr, - const char* className, + const wxString& className, int setThisOwn) { - PyObject* obj; - if (!ptr) { Py_INCREF(Py_None); return Py_None; } char buff[64]; // should always be big enough... - sprintf(buff, "%sPtr", className); + sprintf(buff, "%sPtr", (const char*)className.mbc_str()); - wxASSERT_MSG(wxPython_dict, "wxPython_dict is not set yet!!"); + wxASSERT_MSG(wxPython_dict, wxT("wxPython_dict is not set yet!!")); 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; + wxString msg(wxT("wxPython class not found for ")); + msg += className; + PyErr_SetString(PyExc_NameError, msg.mbc_str()); + return NULL; } return wxPyConstructObject(ptr, className, classobj, setThisOwn); } + //--------------------------------------------------------------------------- @@ -468,7 +805,7 @@ PyThreadState* wxPyGetThreadState() { } } wxPyTMutex->Unlock(); - wxASSERT_MSG(tstate, "PyThreadState should not be NULL!"); + wxASSERT_MSG(tstate, wxT("PyThreadState should not be NULL!")); return tstate; } @@ -483,7 +820,15 @@ void wxPySaveThreadState(PyThreadState* tstate) { for(size_t i=0; i < wxPyTStates->GetCount(); i++) { wxPyThreadState& info = wxPyTStates->Item(i); if (info.tid == ctid) { - info.tstate = tstate; +#if 0 + if (info.tstate != tstate) + wxLogMessage("*** tstate mismatch!???"); +#endif + // info.tstate = tstate; *** DO NOT update existing ones??? + // Normally it will never change, but apparently COM callbacks + // (i.e. ActiveX controls) will (incorrectly IMHO) use a transient + // tstate which will then be garbage the next time we try to use + // it... wxPyTMutex->Unlock(); return; } @@ -530,8 +875,9 @@ void wxPyBeginBlockThreads() { void wxPyEndBlockThreads() { #ifdef WXP_WITH_THREAD - PyThreadState* tstate = PyEval_SaveThread(); // Is there any need to save it again? + // PyThreadState* tstate = + PyEval_SaveThread(); #endif } @@ -539,16 +885,13 @@ void wxPyEndBlockThreads() { //--------------------------------------------------------------------------- // wxPyInputStream and wxPyCBInputStream methods -#include -WX_DEFINE_LIST(wxStringPtrList); - void wxPyInputStream::close() { - /* do nothing */ + /* do nothing for now */ } void wxPyInputStream::flush() { - /* do nothing */ + /* do nothing for now */ } bool wxPyInputStream::eof() { @@ -562,133 +905,132 @@ wxPyInputStream::~wxPyInputStream() { /* do nothing */ } -wxString* wxPyInputStream::read(int size) { - wxString* s = NULL; + + + +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) { + wxPyBeginBlockThreads(); PyErr_SetString(PyExc_IOError, "no valid C-wxInputStream"); + wxPyEndBlockThreads(); return NULL; } if (size < 0) { - // init buffers - char * buf = new char[BUFSIZE]; - if (!buf) { - PyErr_NoMemory(); - return NULL; - } - - s = new wxString(); - if (!s) { - delete buf; - PyErr_NoMemory(); - return NULL; - } - - // read until EOF - while (! m_wxis->Eof()) { - m_wxis->Read(buf, BUFSIZE); - s->Append(buf, m_wxis->LastRead()); - } - delete buf; - - // error check - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { - delete s; - PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); - return NULL; + // read while bytes are available on the stream + while ( m_wxis->CanRead() ) { + m_wxis->Read(buf.GetAppendBuf(BUFSIZE), BUFSIZE); + buf.UngetAppendBuf(m_wxis->LastRead()); } } else { // Read only size number of characters - s = new wxString; - if (!s) { - PyErr_NoMemory(); - return NULL; - } - - // read size bytes - m_wxis->Read(s->GetWriteBuf(size+1), size); - s->UngetWriteBuf(m_wxis->LastRead()); + m_wxis->Read(buf.GetWriteBuf(size), size); + buf.UngetWriteBuf(m_wxis->LastRead()); + } - // error check - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { - delete s; - PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); - return NULL; - } + // error check + wxPyBeginBlockThreads(); + wxStreamError err = m_wxis->GetLastError(); + if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) { + PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); } - return s; + else { + // We use only strings for the streams, not unicode + obj = PyString_FromStringAndSize(buf, buf.GetDataLen()); + } + wxPyEndBlockThreads(); + return obj; } -wxString* wxPyInputStream::readline (int size) { +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) { + wxPyBeginBlockThreads(); PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream"); - return NULL; - } - - // init buffer - int i; - char ch; - wxString* s = new wxString; - if (!s) { - PyErr_NoMemory(); + wxPyEndBlockThreads(); return NULL; } // read until \n or byte limit reached - for (i=ch=0; (ch != '\n') && (!m_wxis->Eof()) && ((size < 0) || (i < size)); i++) { - *s += ch = m_wxis->GetC(); + for (i=ch=0; (ch != '\n') && (m_wxis->CanRead()) && ((size < 0) || (i < size)); i++) { + ch = m_wxis->GetC(); + buf.AppendByte(ch); } // errorcheck - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { - delete s; + wxPyBeginBlockThreads(); + wxStreamError err = m_wxis->GetLastError(); + if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) { PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); - return NULL; } - return s; + else { + // We use only strings for the streams, not unicode + obj = PyString_FromStringAndSize((char*)buf.GetData(), buf.GetDataLen()); + } + wxPyEndBlockThreads(); + return obj; } -wxStringPtrList* wxPyInputStream::readlines (int sizehint) { +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"); + wxPyBeginBlockThreads(); + PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream"); + wxPyEndBlockThreads(); return NULL; } // init list - wxStringPtrList* l = new wxStringPtrList(); - if (!l) { + wxPyBeginBlockThreads(); + pylist = PyList_New(0); + if (!pylist) { + wxPyBeginBlockThreads(); PyErr_NoMemory(); + wxPyEndBlockThreads(); return NULL; } // read sizehint bytes or until EOF int i; - for (i=0; (!m_wxis->Eof()) && ((sizehint < 0) || (i < sizehint));) { - wxString* s = readline(); + for (i=0; (m_wxis->CanRead()) && ((sizehint < 0) || (i < sizehint));) { + PyObject* s = this->readline(); if (s == NULL) { - l->DeleteContents(TRUE); - l->Clear(); + wxPyBeginBlockThreads(); + Py_DECREF(pylist); + wxPyEndBlockThreads(); return NULL; } - l->Append(s); - i = i + s->Length(); + wxPyBeginBlockThreads(); + PyList_Append(pylist, s); + i += PyString_Size(s); + wxPyEndBlockThreads(); } // error check - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { - l->DeleteContents(TRUE); - l->Clear(); + wxStreamError err = m_wxis->GetLastError(); + if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) { + wxPyBeginBlockThreads(); + Py_DECREF(pylist); PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); + wxPyEndBlockThreads(); return NULL; } - return l; + + return pylist; } @@ -740,6 +1082,11 @@ wxPyCBInputStream* wxPyCBInputStream::create(PyObject *py, bool block) { return new wxPyCBInputStream(read, seek, tell, block); } + +wxPyCBInputStream* wxPyCBInputStream_create(PyObject *py, bool block) { + return wxPyCBInputStream::create(py, block); +} + PyObject* wxPyCBInputStream::getMethod(PyObject* py, char* name) { if (!PyObject_HasAttrString(py, name)) return NULL; @@ -775,20 +1122,19 @@ size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) { Py_DECREF(arglist); size_t o = 0; - if ((result != NULL) && PyString_Check(result)) { // TODO: unicode? + 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); + 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; } @@ -855,12 +1201,13 @@ void wxPyCallback::EventThunker(wxEvent& event) { wxPyBeginBlockThreads(); wxString className = event.GetClassInfo()->GetClassName(); - if (className == "wxPyEvent") + if (className == wxT("wxPyEvent")) arg = ((wxPyEvent*)&event)->GetSelf(); - else if (className == "wxPyCommandEvent") + else if (className == wxT("wxPyCommandEvent")) arg = ((wxPyCommandEvent*)&event)->GetSelf(); - else + else { arg = wxPyConstructObject((void*)&event, className); + } tuple = PyTuple_New(1); PyTuple_SET_ITEM(tuple, 0, arg); @@ -905,11 +1252,11 @@ void wxPyCallbackHelper::setSelf(PyObject* self, PyObject* klass, int incref) { // 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 +// 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 actuallt defined... +// code to find the class where the method is actually defined... static PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name) @@ -957,6 +1304,7 @@ PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name) } return NULL; } + return NULL; } #endif @@ -1184,19 +1532,20 @@ void wxPyTimer::Notify() { //--------------------------------------------------------------------------- // Convert a wxList to a Python List -PyObject* wxPy_ConvertList(wxListBase* list, const char* className) { +PyObject* wxPy_ConvertList(wxListBase* listbase, const char* className) { + wxList* list = (wxList*)listbase; // this is probably bad... PyObject* pyList; PyObject* pyObj; wxObject* wxObj; - wxNode* node = list->First(); + wxNode* node = list->GetFirst(); wxPyBeginBlockThreads(); pyList = PyList_New(0); while (node) { - wxObj = node->Data(); + wxObj = node->GetData(); pyObj = wxPyMake_wxObject(wxObj); //wxPyConstructObject(wxObj, className); PyList_Append(pyList, pyObj); - node = node->Next(); + node = node->GetNext(); } wxPyEndBlockThreads(); return pyList; @@ -1212,10 +1561,14 @@ long wxPyGetWinHandle(wxWindow* win) { // Find and return the actual X-Window. #ifdef __WXGTK__ if (win->m_wxwindow) { +#ifdef __WXGTK20__ + return (long) GDK_WINDOW_XWINDOW(GTK_PIZZA(win->m_wxwindow)->bin_window); +#else GdkWindowPrivate* bwin = (GdkWindowPrivate*)GTK_PIZZA(win->m_wxwindow)->bin_window; if (bwin) { return (long)bwin->xwindow; } +#endif } #endif return 0; @@ -1223,7 +1576,117 @@ 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(); + size_t len = PyUnicode_GET_SIZE(source); + if (len) { + PyUnicode_AsWideChar((PyUnicodeObject*)source, target->GetWriteBuf(len), len); + target->UngetWriteBuf(); + } + } 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)) { + size_t len = PyUnicode_GET_SIZE(source); + if (len) { + PyUnicode_AsWideChar((PyUnicodeObject*)source, target.GetWriteBuf(len), len); + target.UngetWriteBuf(); + } + } 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_FromWideChar(src.c_str(), src.Len()); +#else + str = PyString_FromStringAndSize(src.c_str(), src.Len()); +#endif + return str; +} + + +//---------------------------------------------------------------------- byte* byte_LIST_helper(PyObject* source) { @@ -1420,7 +1883,7 @@ error2: if (!isFast) Py_DECREF(o); error1: - delete temp; + delete [] temp; error0: PyErr_SetString(PyExc_TypeError, "Expected a sequence of length-2 sequences or wxPoints."); return NULL; @@ -1478,19 +1941,16 @@ wxString* wxString_LIST_helper(PyObject* source) { 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 + + wxString* pStr = wxString_in_helper(o); + temp[x] = *pStr; + delete pStr; } return temp; } @@ -1564,7 +2024,7 @@ wxPen** wxPen_LIST_helper(PyObject* source) { } -bool _2int_seq_helper(PyObject* source, int* i1, int* i2) { +bool wxPy2int_seq_helper(PyObject* source, int* i1, int* i2) { bool isFast = PyList_Check(source) || PyTuple_Check(source); PyObject *o1, *o2; @@ -1591,7 +2051,7 @@ bool _2int_seq_helper(PyObject* source, int* i1, int* i2) { } -bool _4int_seq_helper(PyObject* source, int* i1, int* i2, int* i3, int* i4) { +bool wxPy4int_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; @@ -1642,7 +2102,14 @@ bool wxSize_helper(PyObject* source, wxSize** obj) { else if (PySequence_Check(source) && PyObject_Length(source) == 2) { PyObject* o1 = PySequence_GetItem(source, 0); PyObject* o2 = PySequence_GetItem(source, 1); + if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) { + Py_DECREF(o1); + Py_DECREF(o2); + goto error; + } **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2)); + Py_DECREF(o1); + Py_DECREF(o2); return TRUE; } @@ -1651,6 +2118,7 @@ bool wxSize_helper(PyObject* source, wxSize** obj) { return FALSE; } + bool wxPoint_helper(PyObject* source, wxPoint** obj) { // If source is an object instance then it may already be the right type @@ -1665,15 +2133,15 @@ bool wxPoint_helper(PyObject* source, wxPoint** obj) { 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: @@ -1697,7 +2165,14 @@ bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) { else if (PySequence_Check(source) && PyObject_Length(source) == 2) { PyObject* o1 = PySequence_GetItem(source, 0); PyObject* o2 = PySequence_GetItem(source, 1); + if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) { + Py_DECREF(o1); + Py_DECREF(o2); + goto error; + } **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2)); + Py_DECREF(o1); + Py_DECREF(o2); return TRUE; } @@ -1725,8 +2200,20 @@ bool wxRect_helper(PyObject* source, wxRect** obj) { PyObject* o2 = PySequence_GetItem(source, 1); PyObject* o3 = PySequence_GetItem(source, 2); PyObject* o4 = PySequence_GetItem(source, 3); + if (!PyNumber_Check(o1) || !PyNumber_Check(o2) || + !PyNumber_Check(o3) || !PyNumber_Check(o4)) { + Py_DECREF(o1); + Py_DECREF(o2); + Py_DECREF(o3); + Py_DECREF(o4); + goto error; + } **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2), - PyInt_AsLong(o3), PyInt_AsLong(o4)); + PyInt_AsLong(o3), PyInt_AsLong(o4)); + Py_DECREF(o1); + Py_DECREF(o2); + Py_DECREF(o3); + Py_DECREF(o4); return TRUE; } @@ -1747,14 +2234,16 @@ bool wxColour_helper(PyObject* source, wxColour** obj) { *obj = ptr; return TRUE; } - // otherwise a string is expected - else if (PyString_Check(source)) { - wxString spec = PyString_AS_STRING(source); - if (spec[0U] == '#' && spec.Length() == 7) { // It's #RRGGBB - char* junk; - int red = strtol(spec.Mid(1,2), &junk, 16); - int green = strtol(spec.Mid(3,2), &junk, 16); - int blue = strtol(spec.Mid(5,2), &junk, 16); + // otherwise check for a string + else if (PyString_Check(source) || PyUnicode_Check(source)) { + wxString spec = Py2wxString(source); + if (spec.GetChar(0) == '#' && spec.Length() == 7) { // It's #RRGGBB + long red, green, blue; + red = green = blue = 0; + spec.Mid(1,2).ToLong(&red, 16); + spec.Mid(3,2).ToLong(&green, 16); + spec.Mid(5,2).ToLong(&blue, 16); + **obj = wxColour(red, green, blue); return TRUE; } @@ -1763,20 +2252,74 @@ bool wxColour_helper(PyObject* source, wxColour** obj) { return TRUE; } } + // last chance: 3-tuple of integers is expected + else if (PySequence_Check(source) && PyObject_Length(source) == 3) { + PyObject* o1 = PySequence_GetItem(source, 0); + PyObject* o2 = PySequence_GetItem(source, 1); + PyObject* o3 = PySequence_GetItem(source, 2); + if (!PyNumber_Check(o1) || !PyNumber_Check(o2) || !PyNumber_Check(o3)) { + Py_DECREF(o1); + Py_DECREF(o2); + Py_DECREF(o3); + goto error; + } + **obj = wxColour(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3)); + Py_DECREF(o1); + Py_DECREF(o2); + Py_DECREF(o3); + return TRUE; + } + + error: + PyErr_SetString(PyExc_TypeError, + "Expected a wxColour object or a string containing a colour name or '#RRGGBB'."); + return FALSE; +} + + +bool wxPoint2DDouble_helper(PyObject* source, wxPoint2DDouble** obj) { + // If source is an object instance then it may already be the right type + if (PyInstance_Check(source)) { + wxPoint2DDouble* ptr; + if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxPoint2DDouble_p")) + goto error; + *obj = ptr; + return TRUE; + } + // otherwise a length-2 sequence of floats is expected + 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 = wxPoint2DDouble(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2)); + Py_DECREF(o1); + Py_DECREF(o2); + return TRUE; + } error: - PyErr_SetString(PyExc_TypeError, "Expected a wxColour object or a string containing a colour name or '#RRGGBB'."); + PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxPoint2DDouble object."); return FALSE; } + //---------------------------------------------------------------------- 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()); +#if wxUSE_UNICODE + PyObject* str = PyUnicode_FromWideChar(arr[i].c_str(), arr[i].Len()); +#else + PyObject* str = PyString_FromStringAndSize(arr[i].c_str(), arr[i].Len()); +#endif PyList_Append(list, str); Py_DECREF(str); }