X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c4770edd1c75ed3bd79130fd3bd84698b0ad7a8c..900eb07b487d457492051da8e846cce49168b5c3:/wxPython/src/helpers.cpp diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp index d61298ef74..e71d858d5b 100644 --- a/wxPython/src/helpers.cpp +++ b/wxPython/src/helpers.cpp @@ -10,7 +10,6 @@ // Licence: wxWindows license ///////////////////////////////////////////////////////////////////////////// -#include // get the correct definition of NULL #undef DEBUG #include @@ -29,6 +28,9 @@ #include #endif +#include +#include +#include //---------------------------------------------------------------------- @@ -38,16 +40,9 @@ //---------------------------------------------------------------------- -#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 bool wxPyDoCleanup = FALSE; +bool wxPyDoingCleanup = FALSE; #ifdef WXP_WITH_THREAD @@ -69,6 +64,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. @@ -92,17 +92,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; } @@ -113,11 +115,12 @@ int wxPyApp::MainLoop() { DeletePendingObjects(); bool initialized = wxTopLevelWindows.GetCount() != 0; -#ifdef __WXGTK__ - m_initialized = initialized; -#endif if (initialized) { + if ( m_exitOnFrameDelete == Later ) { + m_exitOnFrameDelete = Yes; + } + retval = wxApp::MainLoop(); OnExit(); } @@ -125,11 +128,190 @@ 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::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::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 +} + + //--------------------------------------------------------------------- //---------------------------------------------------------------------- +#if 0 static char* wxPyCopyCString(const wxChar* src) { wxWX2MBbuf buff = (wxWX2MBbuf)wxConvCurrent->cWX2MB(src); @@ -162,14 +344,14 @@ static wxChar* wxPyCopyWString(const wxChar *src) return copystring(src); } #endif +#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() +// This function is called when the wxc module is imported to do some initial +// setup. (Before there is a wxApp object.) +void __wxPreStart(PyObject* moduleDict) { #ifdef __WXMSW__ @@ -182,111 +364,93 @@ void __wxPreStart() wxPyTMutex = new wxMutex; #endif - wxApp::CheckBuildOptions(wxBuildOptions()); + // Ensure that the build options in the DLL (or whatever) match this build + wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "wxPython"); - // 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, so we don't need to call wxEntryStart. - if (wxTheApp != NULL) { - return; - } - wxPyDoCleanup = TRUE; - - int argc = 0; - char** argv = NULL; - PyObject* sysargv = PySys_GetObject("argv"); - if (sysargv != NULL) { - 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... + // Get any command-line args passed to this program from the sys module int argc = 0; - wxChar** argv = NULL; + char** argv = NULL; PyObject* sysargv = PySys_GetObject("argv"); if (sysargv != NULL) { argc = PyList_Size(sysargv); - argv = new wxChar*[argc+1]; + argv = new char*[argc+1]; int x; for(x=0; xargc = argc; - wxPythonApp->argv = argv; + if (! wxEntryStart(argc, argv) ) { + PyErr_SetString(PyExc_SystemError, // is this the right one? + "wxEntryStart failed!"); + goto error; + } + delete [] argv; + + + // The stock objects were all NULL when they were loaded into + // SWIG generated proxies, so re-init those now... + wxPy_ReinitStockObjects(); - wxEntryInitGui(); - // Call the Python App's OnInit function + // Call the Python wxApp'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)) { + 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() { + wxPyDoingCleanup = TRUE; if (wxPyDoCleanup) wxEntryCleanup(); #ifdef WXP_WITH_THREAD @@ -300,9 +464,6 @@ void __wxCleanup() { -static PyObject* wxPython_dict = NULL; -static PyObject* wxPyPtrTypeMap = NULL; - PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) { @@ -336,25 +497,133 @@ 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; } + +//--------------------------------------------------------------------------- + +// The stock objects are no longer created when the wxc module is imported, but +// only after the app object has been created. This function will be called before +// OnInit is called so we can hack the new pointer values into the obj.this attributes. + +void wxPy_ReinitStockObjects() +{ + char ptrbuf[128]; + PyObject* obj; + PyObject* ptrobj; + + + +#define REINITOBJ(name, type) \ + obj = PyDict_GetItemString(wxPython_dict, #name); \ + wxASSERT_MSG(obj != NULL, wxT("Unable to find stock object for " #name)); \ + SWIG_MakePtr(ptrbuf, (char *) name, "_" #type "_p"); \ + ptrobj = PyString_FromString(ptrbuf); \ + PyObject_SetAttrString(obj, "this", ptrobj); \ + Py_DECREF(ptrobj) + +#define REINITOBJ2(name, type) \ + obj = PyDict_GetItemString(wxPython_dict, #name); \ + wxASSERT_MSG(obj != NULL, wxT("Unable to find stock object for " #name)); \ + SWIG_MakePtr(ptrbuf, (char *) &name, "_" #type "_p"); \ + ptrobj = PyString_FromString(ptrbuf); \ + PyObject_SetAttrString(obj, "this", ptrobj); \ + Py_DECREF(ptrobj) + + + REINITOBJ(wxNORMAL_FONT, wxFont); + REINITOBJ(wxSMALL_FONT, wxFont); + REINITOBJ(wxITALIC_FONT, wxFont); + REINITOBJ(wxSWISS_FONT, wxFont); + + REINITOBJ(wxRED_PEN, wxPen); + REINITOBJ(wxCYAN_PEN, wxPen); + REINITOBJ(wxGREEN_PEN, wxPen); + REINITOBJ(wxBLACK_PEN, wxPen); + REINITOBJ(wxWHITE_PEN, wxPen); + REINITOBJ(wxTRANSPARENT_PEN, wxPen); + REINITOBJ(wxBLACK_DASHED_PEN, wxPen); + REINITOBJ(wxGREY_PEN, wxPen); + REINITOBJ(wxMEDIUM_GREY_PEN, wxPen); + REINITOBJ(wxLIGHT_GREY_PEN, wxPen); + + REINITOBJ(wxBLUE_BRUSH, wxBrush); + REINITOBJ(wxGREEN_BRUSH, wxBrush); + REINITOBJ(wxWHITE_BRUSH, wxBrush); + REINITOBJ(wxBLACK_BRUSH, wxBrush); + REINITOBJ(wxTRANSPARENT_BRUSH, wxBrush); + REINITOBJ(wxCYAN_BRUSH, wxBrush); + REINITOBJ(wxRED_BRUSH, wxBrush); + REINITOBJ(wxGREY_BRUSH, wxBrush); + REINITOBJ(wxMEDIUM_GREY_BRUSH, wxBrush); + REINITOBJ(wxLIGHT_GREY_BRUSH, wxBrush); + + REINITOBJ(wxBLACK, wxColour); + REINITOBJ(wxWHITE, wxColour); + REINITOBJ(wxRED, wxColour); + REINITOBJ(wxBLUE, wxColour); + REINITOBJ(wxGREEN, wxColour); + REINITOBJ(wxCYAN, wxColour); + REINITOBJ(wxLIGHT_GREY, wxColour); + + REINITOBJ(wxSTANDARD_CURSOR, wxCursor); + REINITOBJ(wxHOURGLASS_CURSOR, wxCursor); + REINITOBJ(wxCROSS_CURSOR, wxCursor); + + REINITOBJ2(wxNullBitmap, wxBitmap); + REINITOBJ2(wxNullIcon, wxIcon); + REINITOBJ2(wxNullCursor, wxCursor); + REINITOBJ2(wxNullPen, wxPen); + REINITOBJ2(wxNullBrush, wxBrush); + REINITOBJ2(wxNullPalette, wxPalette); + REINITOBJ2(wxNullFont, wxFont); + REINITOBJ2(wxNullColour, wxColour); + + REINITOBJ(wxTheFontList, wxFontList); + REINITOBJ(wxThePenList, wxPenList); + REINITOBJ(wxTheBrushList, wxBrushList); + REINITOBJ(wxTheColourDatabase, wxColourDatabase); + + + REINITOBJ(wxTheClipboard, wxClipboard); + REINITOBJ(wxTheMimeTypesManager, wxMimeTypesManager); + REINITOBJ2(wxDefaultValidator, wxValidator); + REINITOBJ2(wxNullImage, wxImage); + REINITOBJ2(wxNullAcceleratorTable, wxAcceleratorTable); + +#undef REINITOBJ +#undef REINITOBJ2 +} + //--------------------------------------------------------------------------- void wxPyClientData_dtor(wxPyClientData* self) { - wxPyBeginBlockThreads(); - Py_DECREF(self->m_obj); - wxPyEndBlockThreads(); + 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) { - wxPyBeginBlockThreads(); - Py_DECREF(self->m_obj); - wxPyEndBlockThreads(); + if (! wxPyDoingCleanup) { + wxPyBeginBlockThreads(); + Py_DECREF(self->m_obj); + wxPyEndBlockThreads(); + } } @@ -377,19 +646,37 @@ void wxPyOORClientData_dtor(wxPyOORClientData* self) { 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 + + // Only if there is more than one reference to the object + if ( !wxPyDoingCleanup && self->m_obj->ob_refcnt > 1 ) { wxASSERT_MSG(PyInstance_Check(self->m_obj), wxT("m_obj not an instance!?!?!")); + + // Call __del__, if there is one. + PyObject* func = PyObject_GetAttrString(self->m_obj, "__del__"); + if (func) { + PyObject* rv = PyObject_CallMethod(self->m_obj, "__del__", NULL); + Py_XDECREF(rv); + Py_DECREF(func); + } + if (PyErr_Occurred()) + PyErr_Clear(); // just ignore it for now + + // Clear the instance's dictionary PyInstanceObject* inst = (PyInstanceObject*)self->m_obj; PyDict_Clear(inst->in_dict); + + // put the name of the old class into the instance, and then reset the + // class to be the dead class. PyDict_SetItemString(inst->in_dict, "_name", inst->in_class->cl_name); inst->in_class = (PyClassObject*)deadObjectClass; Py_INCREF(deadObjectClass); } + + // m_obj is DECREF's in the base class dtor... wxPyEndBlockThreads(); } + //--------------------------------------------------------------------------- // Stuff used by OOR to find the right wxPython class type to return and to // build it. @@ -412,14 +699,26 @@ void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) { 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.mbc_str()); + // 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 } @@ -445,8 +744,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(); @@ -596,7 +895,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; } @@ -683,13 +990,15 @@ PyObject* wxPyInputStream::read(int size) { // 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) { - // read until EOF - while (! m_wxis->Eof()) { + // read while bytes are available on the stream + while ( m_wxis->CanRead() ) { m_wxis->Read(buf.GetAppendBuf(BUFSIZE), BUFSIZE); buf.UngetAppendBuf(m_wxis->LastRead()); } @@ -700,13 +1009,16 @@ PyObject* wxPyInputStream::read(int size) { } // error check - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { + wxPyBeginBlockThreads(); + wxStreamError err = m_wxis->GetLastError(); + if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) { PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); } else { // We use only strings for the streams, not unicode obj = PyString_FromStringAndSize(buf, buf.GetDataLen()); } + wxPyEndBlockThreads(); return obj; } @@ -719,24 +1031,29 @@ PyObject* wxPyInputStream::readline(int size) { // 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; } // read until \n or byte limit reached - for (i=ch=0; (ch != '\n') && (!m_wxis->Eof()) && ((size < 0) || (i < size)); i++) { + 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) { + wxPyBeginBlockThreads(); + wxStreamError err = m_wxis->GetLastError(); + if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) { 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()); } + wxPyEndBlockThreads(); return obj; } @@ -746,33 +1063,45 @@ PyObject* wxPyInputStream::readlines(int sizehint) { // 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 + 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));) { + for (i=0; (m_wxis->CanRead()) && ((sizehint < 0) || (i < sizehint));) { PyObject* s = this->readline(); if (s == NULL) { + wxPyBeginBlockThreads(); Py_DECREF(pylist); + wxPyEndBlockThreads(); return NULL; } + wxPyBeginBlockThreads(); PyList_Append(pylist, s); i += PyString_Size(s); + wxPyEndBlockThreads(); } // error check - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { + 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; } @@ -828,6 +1157,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; @@ -876,7 +1210,6 @@ size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) { else m_lasterror = wxSTREAM_READ_ERROR; wxPyEndBlockThreads(); - m_lastcount = o; return o; } @@ -887,7 +1220,12 @@ size_t wxPyCBInputStream::OnSysWrite(const void *buffer, size_t bufsize) { off_t wxPyCBInputStream::OnSysSeek(off_t off, wxSeekMode mode) { wxPyBeginBlockThreads(); +#ifdef _LARGE_FILES + // off_t is a 64-bit value... + PyObject* arglist = Py_BuildValue("(Li)", off, mode); +#else PyObject* arglist = Py_BuildValue("(ii)", off, mode); +#endif PyObject* result = PyEval_CallObject(m_seek, arglist); Py_DECREF(arglist); Py_XDECREF(result); @@ -895,6 +1233,7 @@ off_t wxPyCBInputStream::OnSysSeek(off_t off, wxSeekMode mode) { return OnSysTell(); } + off_t wxPyCBInputStream::OnSysTell() const { wxPyBeginBlockThreads(); PyObject* arglist = Py_BuildValue("()"); @@ -902,7 +1241,13 @@ off_t wxPyCBInputStream::OnSysTell() const { Py_DECREF(arglist); off_t o = 0; if (result != NULL) { +#ifdef _LARGE_FILES + if (PyLong_Check(result)) + o = PyLong_AsLongLong(result); + else +#else o = PyInt_AsLong(result); +#endif Py_DECREF(result); }; wxPyEndBlockThreads(); @@ -938,29 +1283,50 @@ void wxPyCallback::EventThunker(wxEvent& event) { PyObject* result; PyObject* arg; PyObject* tuple; - + bool checkSkip = FALSE; wxPyBeginBlockThreads(); wxString className = event.GetClassInfo()->GetClassName(); - if (className == "wxPyEvent") - arg = ((wxPyEvent*)&event)->GetSelf(); - else if (className == "wxPyCommandEvent") - arg = ((wxPyCommandEvent*)&event)->GetSelf(); + // If the event is one of these types then pass the original + // event object instead of the one passed to us. + if ( className == wxT("wxPyEvent") ) { + arg = ((wxPyEvent*)&event)->GetSelf(); + checkSkip = ((wxPyEvent*)&event)->GetCloned(); + } + else if ( className == wxT("wxPyCommandEvent") ) { + arg = ((wxPyCommandEvent*)&event)->GetSelf(); + checkSkip = ((wxPyCommandEvent*)&event)->GetCloned(); + } else { arg = wxPyConstructObject((void*)&event, className); } + // Call the event handler, passing the event object tuple = PyTuple_New(1); - PyTuple_SET_ITEM(tuple, 0, arg); + PyTuple_SET_ITEM(tuple, 0, arg); // steals ref to arg result = PyEval_CallObject(func, tuple); - Py_DECREF(tuple); - if (result) { - Py_DECREF(result); + if ( result ) { + Py_DECREF(result); // result is ignored, but we still need to decref it PyErr_Clear(); // Just in case... } else { PyErr_Print(); } + + if ( checkSkip ) { + // if the event object was one of our special types and + // it had been cloned, then we need to extract the Skipped + // value from the original and set it in the clone. + result = PyObject_CallMethod(arg, "GetSkipped", ""); + if ( result ) { + event.Skip(PyInt_AsLong(result)); + Py_DECREF(result); + } else { + PyErr_Print(); + } + } + + Py_DECREF(tuple); wxPyEndBlockThreads(); } @@ -1196,8 +1562,8 @@ IMPLEMENT_ABSTRACT_CLASS(wxPyEvent, wxEvent); IMPLEMENT_ABSTRACT_CLASS(wxPyCommandEvent, wxCommandEvent); -wxPyEvent::wxPyEvent(int id) - : wxEvent(id) { +wxPyEvent::wxPyEvent(int winid, wxEventType commandType) + : wxEvent(winid, commandType) { } @@ -1274,19 +1640,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; @@ -1299,13 +1666,21 @@ long wxPyGetWinHandle(wxWindow* win) { return (long)win->GetHandle(); #endif +#ifdef __WXAC__ + return (long)win->GetHandle(); +#endif + // 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; @@ -1331,7 +1706,12 @@ wxString* wxString_in_helper(PyObject* source) { } #if wxUSE_UNICODE if (PyUnicode_Check(source)) { - target = new wxString(PyUnicode_AS_UNICODE(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; @@ -1373,7 +1753,11 @@ wxString Py2wxString(PyObject* source) #if wxUSE_UNICODE if (PyUnicode_Check(source)) { - target = PyUnicode_AS_UNICODE(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; @@ -1406,7 +1790,7 @@ PyObject* wx2PyString(const wxString& src) { PyObject* str; #if wxUSE_UNICODE - str = PyUnicode_FromUnicode(src.c_str(), src.Len()); + str = PyUnicode_FromWideChar(src.c_str(), src.Len()); #else str = PyString_FromStringAndSize(src.c_str(), src.Len()); #endif @@ -1611,7 +1995,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; @@ -1752,7 +2136,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; @@ -1779,7 +2163,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; @@ -1846,6 +2230,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 @@ -1961,9 +2346,9 @@ 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), *wxConvCurrent); + // 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; @@ -1979,15 +2364,63 @@ 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'."); + "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 2-tuple of floats or a wxPoint2DDouble object."); return FALSE; } + //---------------------------------------------------------------------- PyObject* wxArrayString2PyList_helper(const wxArrayString& arr) { @@ -1995,7 +2428,7 @@ PyObject* wxArrayString2PyList_helper(const wxArrayString& arr) { PyObject* list = PyList_New(0); for (size_t i=0; i < arr.GetCount(); i++) { #if wxUSE_UNICODE - PyObject* str = PyUnicode_FromUnicode(arr[i].c_str(), arr[i].Len()); + PyObject* str = PyUnicode_FromWideChar(arr[i].c_str(), arr[i].Len()); #else PyObject* str = PyString_FromStringAndSize(arr[i].c_str(), arr[i].Len()); #endif