X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/763d71e4420363190f63cf0e99e3a391ca7e90c6..42f8298f6f42d5d63bb3caf65682b7d9d9f8b702:/wxPython/src/helpers.cpp diff --git a/wxPython/src/helpers.cpp b/wxPython/src/helpers.cpp index 8be7e483b5..512b685baa 100644 --- a/wxPython/src/helpers.cpp +++ b/wxPython/src/helpers.cpp @@ -4,7 +4,7 @@ // // Author: Robin Dunn // -// Created: 7/1/97 +// Created: 1-July-1997 // RCS-ID: $Id$ // Copyright: (c) 1998 by Total Control Software // Licence: wxWindows license @@ -13,8 +13,8 @@ #undef DEBUG #include -#include "helpers.h" -#include "pyistream.h" +#include "wx/wxPython/wxPython_int.h" +#include "wx/wxPython/pyistream.h" #ifdef __WXMSW__ #include @@ -23,29 +23,41 @@ #endif #ifdef __WXGTK__ +#include +#include #include #include #include +#define GetXWindow(wxwin) (wxwin)->m_wxwindow ? \ + GDK_WINDOW_XWINDOW(GTK_PIZZA((wxwin)->m_wxwindow)->bin_window) : \ + GDK_WINDOW_XWINDOW((wxwin)->m_widget->window) +#include #endif -//---------------------------------------------------------------------- +#ifdef __WXX11__ +#include "wx/x11/privx.h" +#define GetXWindow(wxwin) ((Window)(wxwin)->GetHandle()) +#endif -#if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE -#error Python must support Unicode to use wxWindows Unicode +#ifdef __WXMAC__ +#include #endif +#include +#include +#include + //---------------------------------------------------------------------- -#ifdef __WXGTK__ -int WXDLLEXPORT wxEntryStart( int& argc, char** argv ); -#else -int WXDLLEXPORT wxEntryStart( int argc, char** argv ); +#if PYTHON_API_VERSION < 1009 && wxUSE_UNICODE +#error Python must support Unicode to use wxWindows Unicode #endif -int WXDLLEXPORT wxEntryInitGui(); -void WXDLLEXPORT wxEntryCleanup(); + +//---------------------------------------------------------------------- wxPyApp* wxPythonApp = NULL; // Global instance of application object -bool wxPyDoCleanup = FALSE; +bool wxPyDoCleanup = false; +bool wxPyDoingCleanup = false; #ifdef WXP_WITH_THREAD @@ -66,6 +78,15 @@ wxPyThreadStateArray* wxPyTStates = NULL; wxMutex* wxPyTMutex = NULL; #endif +#define DEFAULTENCODING_SIZE 64 +static char wxPyDefaultEncoding[DEFAULTENCODING_SIZE] = "ascii"; + +static PyObject* wxPython_dict = NULL; +static PyObject* wxPyAssertionError = NULL; +static PyObject* wxPyNoAppError = NULL; + +PyObject* wxPyPtrTypeMap = NULL; + #ifdef __WXMSW__ // If building for win32... //---------------------------------------------------------------------- @@ -82,7 +103,7 @@ BOOL WINAPI DllMain( // the inatance has already been set. if (! wxGetInstance()) wxSetInstance(hinstDLL); - return TRUE; + return true; } #endif @@ -90,18 +111,22 @@ BOOL WINAPI DllMain( // Classes for implementing the wxp main application shell. //---------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxPyApp, wxApp); + wxPyApp::wxPyApp() { - SetUseBestVisual(TRUE); + m_assertMode = wxPYAPP_ASSERT_EXCEPTION; + m_startupComplete = false; } + wxPyApp::~wxPyApp() { } -// This one isn't acutally called... See __wxStart() +// This one isn't acutally called... We fake it with _BootstrapApp bool wxPyApp::OnInit() { - return FALSE; + return false; } @@ -110,11 +135,11 @@ 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(); } @@ -122,11 +147,340 @@ int wxPyApp::MainLoop() { } +bool wxPyApp::OnInitGui() { + bool rval=true; + wxApp::OnInitGui(); // in this case always call the base class version + bool blocked = wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "OnInitGui")) + rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); + wxPyEndBlockThreads(blocked); + return rval; +} + + +int wxPyApp::OnExit() { + int rval=0; + bool blocked = wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "OnExit")) + rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); + wxPyEndBlockThreads(blocked); + 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 we're not fully initialized then just log the error + if (! m_startupComplete) { + 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); + return; + } + + // If the OnAssert is overloaded in the Python class then call it... + bool found; + bool blocked = 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(blocked); + + // ...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 + bool blocked = wxPyBeginBlockThreads(); + PyObject* s = wx2PyString(buf); + PyErr_SetObject(wxPyAssertionError, s); + Py_DECREF(s); + wxPyEndBlockThreads(blocked); + + // 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 + + // For catching Apple Events +void wxPyApp::MacOpenFile(const wxString &fileName) +{ + bool blocked = wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "MacOpenFile")) { + PyObject* s = wx2PyString(fileName); + wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s)); + Py_DECREF(s); + } + wxPyEndBlockThreads(blocked); +} + +void wxPyApp::MacPrintFile(const wxString &fileName) +{ + bool blocked = wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "MacPrintFile")) { + PyObject* s = wx2PyString(fileName); + wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", s)); + Py_DECREF(s); + } + wxPyEndBlockThreads(blocked); +} + +void wxPyApp::MacNewFile() +{ + bool blocked = wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "MacNewFile")) + wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); + wxPyEndBlockThreads(blocked); +} + +void wxPyApp::MacReopenApp() +{ + bool blocked = wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "MacReopenApp")) + wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); + wxPyEndBlockThreads(blocked); +} + + +/*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 +} + + +// This finishes the initialization of wxWindows and then calls the OnInit +// that should be present in the derived (Python) class. +void wxPyApp::_BootstrapApp() +{ + static bool haveInitialized = false; + bool result, blocked; + PyObject* retval = NULL; + PyObject* pyint = NULL; + + + // Only initialize wxWidgets once + if (! haveInitialized) { + + // Get any command-line args passed to this program from the sys module + int argc = 0; + char** argv = NULL; + blocked = wxPyBeginBlockThreads(); + PyObject* sysargv = PySys_GetObject("argv"); + if (sysargv != NULL) { + argc = PyList_Size(sysargv); + argv = new char*[argc+1]; + int x; + for(x=0; xSetStartupComplete(true); + + // Call the Python wxApp's OnInit function + blocked = wxPyBeginBlockThreads(); + if (wxPyCBH_findCallback(m_myInst, "OnInit")) { + + PyObject* method = m_myInst.GetLastFound(); + PyObject* argTuple = PyTuple_New(0); + retval = PyEval_CallObject(method, argTuple); + Py_DECREF(argTuple); + Py_DECREF(method); + if (retval == NULL) + goto error; + + pyint = PyNumber_Int(retval); + if (! pyint) { + PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value"); + goto error; + } + result = PyInt_AS_LONG(pyint); + } + else { + // Is it okay if there is no OnInit? Probably so... + result = true; + } + + if (! result) { + PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting..."); + } + + error: + Py_XDECREF(retval); + Py_XDECREF(pyint); + + wxPyEndBlockThreads(blocked); +}; //--------------------------------------------------------------------- //---------------------------------------------------------------------- +#if 0 static char* wxPyCopyCString(const wxChar* src) { wxWX2MBbuf buff = (wxWX2MBbuf)wxConvCurrent->cWX2MB(src); @@ -159,126 +513,58 @@ static wxChar* wxPyCopyWString(const wxChar *src) return copystring(src); } #endif +#endif + +inline const char* dropwx(const char* name) { + if (name[0] == 'w' && name[1] == 'x') + return name+2; + else + return name; +} //---------------------------------------------------------------------- -// 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 wx._core_ module is imported to do some +// initial setup. (Before there is a wxApp object.) The rest happens in +// wxPyApp::_BootstrapApp +void __wxPyPreStart(PyObject* moduleDict) { #ifdef __WXMSW__ -// wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF); +// wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF +// | _CRTDBG_CHECK_ALWAYS_DF +// | _CRTDBG_DELAY_FREE_MEM_DF +// ); #endif #ifdef WXP_WITH_THREAD PyEval_InitThreads(); wxPyTStates = new wxPyThreadStateArray; wxPyTMutex = new wxMutex; -#endif - - wxApp::CheckBuildOptions(wxBuildOptions()); - - // 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; xargc = argc; - wxPythonApp->argv = argv; + // Ensure that the build options in the DLL (or whatever) match this build + wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "wxPython"); - wxEntryInitGui(); + // Init the stock objects to a non-NULL value so SWIG doesn't create them as None + wxPy_ReinitStockObjects(1); - // Call the Python App's OnInit function - arglist = PyTuple_New(0); - result = PyEval_CallObject(onInitFunc, arglist); - if (!result) { // an exception was raised. - return NULL; - } - - if (! PyInt_Check(result)) { - PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value"); - return NULL; - } - bResult = PyInt_AS_LONG(result); - if (! bResult) { - PyErr_SetString(PyExc_SystemExit, "OnInit returned FALSE, exiting..."); - return NULL; - } - -#ifdef __WXGTK__ - wxTheApp->m_initialized = (wxTopLevelWindows.GetCount() > 0); -#endif - - Py_INCREF(Py_None); - return Py_None; + wxInitAllImageHandlers(); } -void __wxCleanup() { - if (wxPyDoCleanup) + +void __wxPyCleanup() { + wxPyDoingCleanup = true; + if (wxPyDoCleanup) { + wxPyDoCleanup = false; wxEntryCleanup(); + } #ifdef WXP_WITH_THREAD delete wxPyTMutex; wxPyTMutex = NULL; @@ -289,19 +575,17 @@ void __wxCleanup() { } - -static PyObject* wxPython_dict = NULL; -static PyObject* wxPyPtrTypeMap = NULL; - - -PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) +// Save a reference to the dictionary of the wx._core module, and inject +// a few more things into it. +PyObject* __wxPySetDictionary(PyObject* /* self */, PyObject* args) { if (!PyArg_ParseTuple(args, "O", &wxPython_dict)) return NULL; if (!PyDict_Check(wxPython_dict)) { - PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!"); + PyErr_SetString(PyExc_TypeError, + "_wxPySetDictionary must have dictionary object!"); return NULL; } @@ -309,45 +593,303 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) wxPyPtrTypeMap = PyDict_New(); PyDict_SetItemString(wxPython_dict, "__wxPyPtrTypeMap", wxPyPtrTypeMap); + // Create an exception object to use for wxASSERTions + wxPyAssertionError = PyErr_NewException("wx._core.PyAssertionError", + PyExc_AssertionError, NULL); + PyDict_SetItemString(wxPython_dict, "PyAssertionError", wxPyAssertionError); + + // Create an exception object to use when the app object hasn't been created yet + wxPyNoAppError = PyErr_NewException("wx._core.PyNoAppError", + PyExc_RuntimeError, NULL); + PyDict_SetItemString(wxPython_dict, "PyNoAppError", wxPyNoAppError); + + #ifdef __WXMOTIF__ #define wxPlatform "__WXMOTIF__" +#define wxPlatName "wxMotif" #endif #ifdef __WXX11__ #define wxPlatform "__WXX11__" +#define wxPlatName "wxX11" #endif #ifdef __WXGTK__ #define wxPlatform "__WXGTK__" +#define wxPlatName "wxGTK" #endif -#if defined(__WIN32__) || defined(__WXMSW__) +#ifdef __WXMSW__ #define wxPlatform "__WXMSW__" +#define wxPlatName "wxMSW" #endif #ifdef __WXMAC__ #define wxPlatform "__WXMAC__" +#define wxPlatName "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)); + // These should be deprecated in favor of the PlatformInfo tuple built below... + PyDict_SetItemString(wxPython_dict, "Platform", PyString_FromString(wxPlatform)); + PyDict_SetItemString(wxPython_dict, "USE_UNICODE", PyInt_FromLong(wxUSE_UNICODE)); + PyDict_SetItemString(wxPython_dict, "__WXDEBUG__", PyInt_FromLong(wxdebug)); + + // Make a tuple of strings that gives more info about the platform. + PyObject* PlatInfo = PyList_New(0); + PyObject* obj; + +#define _AddInfoString(st) \ + obj = PyString_FromString(st); \ + PyList_Append(PlatInfo, obj); \ + Py_DECREF(obj) - Py_INCREF(Py_None); - return Py_None; + _AddInfoString(wxPlatform); + _AddInfoString(wxPlatName); +#if wxUSE_UNICODE + _AddInfoString("unicode"); +#else + _AddInfoString("ansi"); +#endif +#ifdef __WXGTK__ +#ifdef __WXGTK20__ + _AddInfoString("gtk2"); +#else + _AddInfoString("gtk1"); +#endif +#endif +#ifdef __WXDEBUG__ + _AddInfoString("wx-assertions-on"); +#else + _AddInfoString("wx-assertions-off"); +#endif + +#undef _AddInfoString + + PyObject* PlatInfoTuple = PyList_AsTuple(PlatInfo); + Py_DECREF(PlatInfo); + PyDict_SetItemString(wxPython_dict, "PlatformInfo", PlatInfoTuple); + + RETURN_NONE(); } + //--------------------------------------------------------------------------- -void wxPyClientData_dtor(wxPyClientData* self) { - wxPyBeginBlockThreads(); - Py_DECREF(self->m_obj); - wxPyEndBlockThreads(); +// Python's PyInstance_Check does not return True for instances of new-style +// classes. This should get close enough for both new and old classes but I +// should re-evaluate the need for doing instance checks... +bool wxPyInstance_Check(PyObject* obj) { + return PyObject_HasAttrString(obj, "__class__") != 0; +} + + +// This one checks if the object is an instance of a SWIG proxy class (it has +// a .this attribute) +bool wxPySwigInstance_Check(PyObject* obj) { + return PyObject_HasAttrString(obj, "this") != 0; +} + +//--------------------------------------------------------------------------- + +// The stock objects are no longer created when the wx._core_ module is +// imported, but only after the app object has been created. The +// wxPy_ReinitStockObjects function will be called 3 times to pass the stock +// objects though various stages of evolution: +// +// pass 1: Set all the pointers to a non-NULL value so the Python proxy +// object will be created (otherwise SWIG will just use None.) +// +// pass 2: After the module has been imported and the python proxys have +// been created, then set the __class__ to be _wxPyUnbornObject so +// it will catch any access to the object and will raise an exception. +// +// pass 3: Finally, from BootstrapApp patch things up so the stock objects +// can be used. + + +PyObject* __wxPyFixStockObjects(PyObject* /* self */, PyObject* args) +{ + wxPy_ReinitStockObjects(2); + RETURN_NONE(); +} + + +static void rsoPass2(const char* name) +{ + static PyObject* unbornObjectClass = NULL; + PyObject* obj; + + if (unbornObjectClass == NULL) { + unbornObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyUnbornObject"); + Py_INCREF(unbornObjectClass); + } + + // Find the object instance + obj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(name)); + wxCHECK_RET(obj != NULL, wxT("Unable to find stock object")); + wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance")); + + // Change its class + PyObject_SetAttrString(obj, "__class__", unbornObjectClass); + +} + +static void rsoPass3(const char* name, const char* classname, void* ptr) +{ + PyObject* obj; + PyObject* classobj; + PyObject* ptrobj; + + // Find the object instance + obj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(name)); + wxCHECK_RET(obj != NULL, wxT("Unable to find stock object")); + wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance")); + + // Find the class object and put it back in the instance + classobj = PyDict_GetItemString(wxPython_dict, (char*)dropwx(classname)); + wxCHECK_RET(classobj != NULL, wxT("Unable to find stock class object")); + PyObject_SetAttrString(obj, "__class__", classobj); + + // Rebuild the .this swigified pointer with the new value of the C++ pointer + ptrobj = wxPyMakeSwigPtr(ptr, wxString(classname, *wxConvCurrent)); + PyObject_SetAttrString(obj, "this", ptrobj); + Py_DECREF(ptrobj); } + + +void wxPy_ReinitStockObjects(int pass) +{ + + // If there is already an App object then wxPython is probably embedded in + // a wx C++ application, so there is no need to do all this. + static bool embedded = false; + if ((pass == 1 || pass == 2) && wxTheApp) { + embedded = true; + return; + } + if (pass == 3 && embedded) + return; + + +#define REINITOBJ(name, classname) \ + if (pass == 1) { name = (classname*)0xC0C0C0C0; } \ + else if (pass == 2) { rsoPass2(#name); } \ + else if (pass == 3) { rsoPass3(#name, #classname, (void*)name); } + + +#define REINITOBJ2(name, classname) \ + if (pass == 1) { } \ + else if (pass == 2) { rsoPass2(#name); } \ + else if (pass == 3) { rsoPass3(#name, #classname, (void*)&name); } + + + 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); + + + REINITOBJ2(wxDefaultValidator, wxValidator); + REINITOBJ2(wxNullImage, wxImage); + REINITOBJ2(wxNullAcceleratorTable, wxAcceleratorTable); + +#undef REINITOBJ +#undef REINITOBJ2 +} + +//--------------------------------------------------------------------------- + +// Check for existence of a wxApp, setting an exception if there isn't one. +// This doesn't need to aquire the GIL because it should only be called from +// an %exception before the lock is released. + +bool wxPyCheckForApp() { + if (wxTheApp != NULL) + return true; + else { + PyErr_SetString(wxPyNoAppError, "The wx.App object must be created first!"); + return false; + } +} + +//--------------------------------------------------------------------------- + void wxPyUserData_dtor(wxPyUserData* self) { - wxPyBeginBlockThreads(); - Py_DECREF(self->m_obj); - wxPyEndBlockThreads(); + if (! wxPyDoingCleanup) { + bool blocked = wxPyBeginBlockThreads(); + Py_DECREF(self->m_obj); + self->m_obj = NULL; + wxPyEndBlockThreads(blocked); + } +} + + +void wxPyClientData_dtor(wxPyClientData* self) { + if (! wxPyDoingCleanup) { // Don't do it during cleanup as Python + // may have already garbage collected the object... + if (self->m_incRef) { + bool blocked = wxPyBeginBlockThreads(); + Py_DECREF(self->m_obj); + wxPyEndBlockThreads(blocked); + } + self->m_obj = NULL; + } } + // 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 @@ -355,31 +897,61 @@ void wxPyUserData_dtor(wxPyUserData* self) { // 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. +// _wxPyDeadObject in _core_ex.py for the implementation of this class. void wxPyOORClientData_dtor(wxPyOORClientData* self) { static PyObject* deadObjectClass = NULL; - wxPyBeginBlockThreads(); + bool blocked = wxPyBeginBlockThreads(); if (deadObjectClass == NULL) { deadObjectClass = PyDict_GetItemString(wxPython_dict, "_wxPyDeadObject"); - wxASSERT_MSG(deadObjectClass != NULL, wxT("Can't get _wxPyDeadObject class!")); + // TODO: Can not wxASSERT here because inside a wxPyBeginBlock Threads, + // will lead to a deadlock when it tries to aquire the GIL again. + //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); + + // Only if there is more than one reference to the object and we are + // holding the OOR reference: + if ( !wxPyDoingCleanup && self->m_obj->ob_refcnt > 1 && self->m_incRef) { + // bool isInstance = wxPyInstance_Check(self->m_obj); + // TODO same here + //wxASSERT_MSG(isInstance, 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 + + + PyObject* dict = PyObject_GetAttrString(self->m_obj, "__dict__"); + if (dict) { + // Clear the instance's dictionary + PyDict_Clear(dict); + + // put the name of the old class into the instance, and then reset the + // class to be the dead class. + PyObject* klass = PyObject_GetAttrString(self->m_obj, "__class__"); + PyObject* name = PyObject_GetAttrString(klass, "__name__"); + PyDict_SetItemString(dict, "_name", name); + PyObject_SetAttrString(self->m_obj, "__class__", deadObjectClass); + //Py_INCREF(deadObjectClass); + Py_DECREF(klass); + Py_DECREF(name); + } } - wxPyEndBlockThreads(); + + // m_obj is DECREF'd in the base class dtor... + wxPyEndBlockThreads(blocked); } + //--------------------------------------------------------------------------- // Stuff used by OOR to find the right wxPython class type to return and to // build it. @@ -400,51 +972,41 @@ void wxPyPtrTypeMap_Add(const char* commonName, const char* ptrName) { -PyObject* wxPyClassExists(const wxString& className) { - - if (!className) - return NULL; - - char buff[64]; // should always be big enough... - - 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, bool checkEvtHandler) { +PyObject* wxPyMake_wxObject(wxObject* source, bool setThisOwn, bool checkEvtHandler) { PyObject* target = NULL; - bool isEvtHandler = FALSE; + bool isEvtHandler = false; if (source) { // 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; + isEvtHandler = true; wxEvtHandler* eh = (wxEvtHandler*)source; wxPyOORClientData* data = (wxPyOORClientData*)eh->GetClientObject(); if (data) { target = data->m_obj; - Py_INCREF(target); + if (target) + Py_INCREF(target); } } if (! target) { - // Otherwise make it the old fashioned way by making a - // new shadow object and putting this pointer in it. - wxClassInfo* info = source->GetClassInfo(); - wxChar* name = (wxChar*)info->GetClassName(); - PyObject* klass = wxPyClassExists(name); - while (info && !klass) { - name = (wxChar*)info->GetBaseClassName1(); - info = wxClassInfo::FindClass(name); - klass = wxPyClassExists(name); + // Otherwise make it the old fashioned way by making a new shadow + // object and putting this pointer in it. Look up the class + // heirarchy until we find a class name that is located in the + // python module. + const wxClassInfo* info = source->GetClassInfo(); + wxString name = info->GetClassName(); + bool exists = wxPyCheckSwigType(name); + while (info && !exists) { + info = info->GetBaseClass1(); + name = info->GetClassName(); + exists = wxPyCheckSwigType(name); } if (info) { - target = wxPyConstructObject(source, name, klass, FALSE); + target = wxPyConstructObject((void*)source, name, setThisOwn); if (target && isEvtHandler) ((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target)); } else { @@ -461,22 +1023,22 @@ PyObject* wxPyMake_wxObject(wxObject* source, bool checkEvtHandler) { } -PyObject* wxPyMake_wxSizer(wxSizer* source) { +PyObject* wxPyMake_wxSizer(wxSizer* source, bool setThisOwn) { 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. + // 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) + Py_INCREF(target); } } if (! target) { - target = wxPyMake_wxObject(source, FALSE); + target = wxPyMake_wxObject(source, setThisOwn, false); if (target != Py_None) ((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target)); } @@ -484,66 +1046,6 @@ PyObject* wxPyMake_wxSizer(wxSizer* source) { } - -//--------------------------------------------------------------------------- - -PyObject* wxPyConstructObject(void* ptr, - 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*)(const char*)name.mbc_str())) != NULL) { - name = wxString(PyString_AsString(item), *wxConvCurrent); - } - sprintf(buff, "_%s_p", (const char*)name.mbc_str()); - SWIG_MakePtr(swigptr, ptr, buff); - - arg = Py_BuildValue("(s)", swigptr); - obj = PyInstance_New(klass, arg, NULL); - Py_DECREF(arg); - - if (setThisOwn) { - PyObject* one = PyInt_FromLong(1); - PyObject_SetAttrString(obj, "thisown", one); - Py_DECREF(one); - } - - return obj; -} - - -PyObject* wxPyConstructObject(void* ptr, - const wxString& className, - int setThisOwn) { - if (!ptr) { - Py_INCREF(Py_None); - return Py_None; - } - - 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!!")); - - PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff); - if (! classobj) { - 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); -} - - //--------------------------------------------------------------------------- @@ -553,20 +1055,21 @@ unsigned long wxPyGetCurrentThreadId() { return wxThread::GetCurrentId(); } -static PyThreadState* gs_shutdownTState; +static wxPyThreadState gs_shutdownTState; + static -PyThreadState* wxPyGetThreadState() { +wxPyThreadState* wxPyGetThreadState() { if (wxPyTMutex == NULL) // Python is shutting down... - return gs_shutdownTState; + return &gs_shutdownTState; unsigned long ctid = wxPyGetCurrentThreadId(); - PyThreadState* tstate = NULL; + wxPyThreadState* 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; + tstate = &info; break; } } @@ -575,10 +1078,11 @@ PyThreadState* wxPyGetThreadState() { return tstate; } + static void wxPySaveThreadState(PyThreadState* tstate) { if (wxPyTMutex == NULL) { // Python is shutting down, assume a single thread... - gs_shutdownTState = tstate; + gs_shutdownTState.tstate = tstate; return; } unsigned long ctid = wxPyGetCurrentThreadId(); @@ -590,11 +1094,12 @@ void wxPySaveThreadState(PyThreadState* tstate) { if (info.tstate != tstate) wxLogMessage("*** tstate mismatch!???"); #endif - // info.tstate = tstate; *** DO NOT updating existing ones??? + info.tstate = tstate; // allow for transient tstates // Normally it will never change, but apparently COM callbacks // (i.e. ActiveX controls) will (incorrectly IMHO) use a transient - // tstate wich will then be garbage the next time we try to use + // tstate which will then be garbage the next time we try to use // it... + wxPyTMutex->Unlock(); return; } @@ -607,6 +1112,7 @@ void wxPySaveThreadState(PyThreadState* tstate) { #endif + // Calls from Python to wxWindows code are wrapped in calls to these // functions: @@ -631,19 +1137,35 @@ void wxPyEndAllowThreads(PyThreadState* saved) { // Calls from wxWindows back to Python code, or even any PyObject // manipulations, PyDECREF's and etc. are wrapped in calls to these functions: -void wxPyBeginBlockThreads() { +bool wxPyBeginBlockThreads() { #ifdef WXP_WITH_THREAD - PyThreadState* tstate = wxPyGetThreadState(); - PyEval_RestoreThread(tstate); + // This works in for 2.3, maybe a good alternative to find the needed tstate? + // PyThreadState *check = PyGILState_GetThisThreadState(); + + PyThreadState *current = _PyThreadState_Current; + + // Only block if there wasn't already a tstate, or if the current one is + // not the one we are wanting to change to. This should prevent deadlock + // if there are nested calls to wxPyBeginBlockThreads + bool blocked = false; + wxPyThreadState* tstate = wxPyGetThreadState(); + if (current != tstate->tstate) { + PyEval_RestoreThread(tstate->tstate); + blocked = true; + } + return blocked; #endif } -void wxPyEndBlockThreads() { +void wxPyEndBlockThreads(bool blocked) { #ifdef WXP_WITH_THREAD - // Is there any need to save it again? - // PyThreadState* tstate = - PyEval_SaveThread(); + // Only unblock if we blocked in the last call to wxPyBeginBlockThreads. + // The value of blocked passed in needs to be the same as that returned + // from wxPyBeginBlockThreads at the same nesting level. + if ( blocked ) { + PyEval_SaveThread(); + } #endif } @@ -664,11 +1186,12 @@ bool wxPyInputStream::eof() { if (m_wxis) return m_wxis->Eof(); else - return TRUE; + return true; } wxPyInputStream::~wxPyInputStream() { - /* do nothing */ + if (m_wxis) + delete m_wxis; } @@ -681,13 +1204,15 @@ PyObject* wxPyInputStream::read(int size) { // check if we have a real wxInputStream to work with if (!m_wxis) { + bool blocked = wxPyBeginBlockThreads(); PyErr_SetString(PyExc_IOError, "no valid C-wxInputStream"); + wxPyEndBlockThreads(blocked); 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()); } @@ -698,13 +1223,16 @@ PyObject* wxPyInputStream::read(int size) { } // error check - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { + bool blocked = 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(blocked); return obj; } @@ -717,24 +1245,29 @@ PyObject* wxPyInputStream::readline(int size) { // check if we have a real wxInputStream to work with if (!m_wxis) { + bool blocked = wxPyBeginBlockThreads(); PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream"); + wxPyEndBlockThreads(blocked); 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) { + bool blocked = 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(blocked); return obj; } @@ -744,33 +1277,47 @@ 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"); + bool blocked = wxPyBeginBlockThreads(); + PyErr_SetString(PyExc_IOError,"no valid C-wxInputStream"); + wxPyEndBlockThreads(blocked); return NULL; } // init list + bool blocked = wxPyBeginBlockThreads(); pylist = PyList_New(0); + wxPyEndBlockThreads(blocked); + if (!pylist) { + bool blocked = wxPyBeginBlockThreads(); PyErr_NoMemory(); + wxPyEndBlockThreads(blocked); 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) { + bool blocked = wxPyBeginBlockThreads(); Py_DECREF(pylist); + wxPyEndBlockThreads(blocked); return NULL; } + bool blocked = wxPyBeginBlockThreads(); PyList_Append(pylist, s); i += PyString_Size(s); + wxPyEndBlockThreads(blocked); } // error check - if (m_wxis->LastError() == wxSTREAM_READ_ERROR) { + wxStreamError err = m_wxis->GetLastError(); + if (err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF) { + bool blocked = wxPyBeginBlockThreads(); Py_DECREF(pylist); PyErr_SetString(PyExc_IOError,"IOError in wxInputStream"); + wxPyEndBlockThreads(blocked); return NULL; } @@ -798,16 +1345,18 @@ wxPyCBInputStream::wxPyCBInputStream(PyObject *r, PyObject *s, PyObject *t, bool wxPyCBInputStream::~wxPyCBInputStream() { - if (m_block) wxPyBeginBlockThreads(); + bool blocked=false; + if (m_block) blocked = wxPyBeginBlockThreads(); Py_XDECREF(m_read); Py_XDECREF(m_seek); Py_XDECREF(m_tell); - if (m_block) wxPyEndBlockThreads(); + if (m_block) wxPyEndBlockThreads(blocked); } wxPyCBInputStream* wxPyCBInputStream::create(PyObject *py, bool block) { - if (block) wxPyBeginBlockThreads(); + bool blocked=false; + if (block) blocked = wxPyBeginBlockThreads(); PyObject* read = getMethod(py, "read"); PyObject* seek = getMethod(py, "seek"); @@ -818,14 +1367,19 @@ wxPyCBInputStream* wxPyCBInputStream::create(PyObject *py, bool block) { Py_XDECREF(read); Py_XDECREF(seek); Py_XDECREF(tell); - if (block) wxPyEndBlockThreads(); + if (block) wxPyEndBlockThreads(blocked); return NULL; } - if (block) wxPyEndBlockThreads(); + if (block) wxPyEndBlockThreads(blocked); 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; @@ -838,16 +1392,16 @@ PyObject* wxPyCBInputStream::getMethod(PyObject* py, char* name) { } -size_t wxPyCBInputStream::GetSize() const { +wxFileOffset wxPyCBInputStream::GetLength() 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); + wxFileOffset temp = self->OnSysTell(); + wxFileOffset ret = self->OnSysSeek(0, wxFromEnd); self->OnSysSeek(temp, wxFromStart); return ret; } else - return 0; + return wxInvalidOffset; } @@ -855,7 +1409,7 @@ size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) { if (bufsize == 0) return 0; - wxPyBeginBlockThreads(); + bool blocked = wxPyBeginBlockThreads(); PyObject* arglist = Py_BuildValue("(i)", bufsize); PyObject* result = PyEval_CallObject(m_read, arglist); Py_DECREF(arglist); @@ -873,8 +1427,7 @@ size_t wxPyCBInputStream::OnSysRead(void *buffer, size_t bufsize) { } else m_lasterror = wxSTREAM_READ_ERROR; - wxPyEndBlockThreads(); - m_lastcount = o; + wxPyEndBlockThreads(blocked); return o; } @@ -883,33 +1436,48 @@ size_t wxPyCBInputStream::OnSysWrite(const void *buffer, size_t bufsize) { return 0; } -off_t wxPyCBInputStream::OnSysSeek(off_t off, wxSeekMode mode) { - wxPyBeginBlockThreads(); - PyObject* arglist = Py_BuildValue("(ii)", off, mode); + +wxFileOffset wxPyCBInputStream::OnSysSeek(wxFileOffset off, wxSeekMode mode) { + bool blocked = wxPyBeginBlockThreads(); + PyObject* arglist = PyTuple_New(2); + + if (sizeof(wxFileOffset) > sizeof(long)) + // wxFileOffset is a 64-bit value... + PyTuple_SET_ITEM(arglist, 0, PyLong_FromLongLong(off)); + else + PyTuple_SET_ITEM(arglist, 0, PyInt_FromLong(off)); + + PyTuple_SET_ITEM(arglist, 1, PyInt_FromLong(mode)); + + PyObject* result = PyEval_CallObject(m_seek, arglist); Py_DECREF(arglist); Py_XDECREF(result); - wxPyEndBlockThreads(); + wxPyEndBlockThreads(blocked); return OnSysTell(); } -off_t wxPyCBInputStream::OnSysTell() const { - wxPyBeginBlockThreads(); + +wxFileOffset wxPyCBInputStream::OnSysTell() const { + bool blocked = wxPyBeginBlockThreads(); PyObject* arglist = Py_BuildValue("()"); PyObject* result = PyEval_CallObject(m_tell, arglist); Py_DECREF(arglist); - off_t o = 0; + wxFileOffset o = 0; if (result != NULL) { - o = PyInt_AsLong(result); + if (PyLong_Check(result)) + o = PyLong_AsLongLong(result); + else + o = PyInt_AsLong(result); Py_DECREF(result); }; - wxPyEndBlockThreads(); + wxPyEndBlockThreads(blocked); return o; } //---------------------------------------------------------------------- -IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject); +IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxEvtHandler); wxPyCallback::wxPyCallback(PyObject* func) { m_func = func; @@ -922,12 +1490,14 @@ wxPyCallback::wxPyCallback(const wxPyCallback& other) { } wxPyCallback::~wxPyCallback() { - wxPyBeginBlockThreads(); + bool blocked = wxPyBeginBlockThreads(); Py_DECREF(m_func); - wxPyEndBlockThreads(); + wxPyEndBlockThreads(blocked); } +#define wxPy_PRECALLINIT "_preCallInit" +#define wxPy_POSTCALLCLEANUP "_postCallCleanup" // This function is used for all events destined for Python event handlers. void wxPyCallback::EventThunker(wxEvent& event) { @@ -936,30 +1506,84 @@ void wxPyCallback::EventThunker(wxEvent& event) { PyObject* result; PyObject* arg; PyObject* tuple; + bool checkSkip = false; - - wxPyBeginBlockThreads(); + bool blocked = 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); } - tuple = PyTuple_New(1); - PyTuple_SET_ITEM(tuple, 0, arg); - result = PyEval_CallObject(func, tuple); - Py_DECREF(tuple); - if (result) { - Py_DECREF(result); - PyErr_Clear(); // Just in case... - } else { + if (!arg) { PyErr_Print(); + } else { + // "intern" the pre/post method names to speed up the HasAttr + static PyObject* s_preName = NULL; + static PyObject* s_postName = NULL; + if (s_preName == NULL) { + s_preName = PyString_FromString(wxPy_PRECALLINIT); + s_postName = PyString_FromString(wxPy_POSTCALLCLEANUP); + } + + // Check if the event object needs some preinitialization + if (PyObject_HasAttr(arg, s_preName)) { + result = PyObject_CallMethodObjArgs(arg, s_preName, arg, NULL); + if ( result ) { + Py_DECREF(result); // result is ignored, but we still need to decref it + PyErr_Clear(); // Just in case... + } else { + PyErr_Print(); + } + } + + // Call the event handler, passing the event object + tuple = PyTuple_New(1); + PyTuple_SET_ITEM(tuple, 0, arg); // steals ref to arg + result = PyEval_CallObject(func, tuple); + if ( result ) { + Py_DECREF(result); // result is ignored, but we still need to decref it + PyErr_Clear(); // Just in case... + } else { + PyErr_Print(); + } + + // Check if the event object needs some post cleanup + if (PyObject_HasAttr(arg, s_postName)) { + result = PyObject_CallMethodObjArgs(arg, s_postName, arg, NULL); + 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(); + wxPyEndBlockThreads(blocked); } @@ -1005,7 +1629,6 @@ PyObject* PyFindClassWithAttr(PyObject *klass, PyObject *name) 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 */ @@ -1080,7 +1703,7 @@ bool wxPyCallbackHelper::findCallback(const char* name) const { // not from a base class... if (PyMethod_Check(method) && (klass = PyMethod_GetDefiningClass(method, (char*)name)) != NULL && - ((klass == m_class) || PyClass_IsSubclass(klass, m_class))) { + ((klass == m_class) || PyObject_IsSubclass(klass, m_class))) { // ...then we'll save a pointer to the method so callCallback can call it. self->m_lastFound = method; @@ -1095,7 +1718,7 @@ bool wxPyCallbackHelper::findCallback(const char* name) const { int wxPyCallbackHelper::callCallback(PyObject* argTuple) const { PyObject* result; - int retval = FALSE; + int retval = false; result = callCallbackObj(argTuple); if (result) { // Assumes an integer return type... @@ -1107,7 +1730,7 @@ int wxPyCallbackHelper::callCallback(PyObject* argTuple) const { } // Invoke the Python callable object, returning the raw PyObject return -// value. Caller should DECREF the return value and also call PyEval_SaveThread. +// value. Caller should DECREF the return value and also manage the GIL. PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) const { PyObject* result; @@ -1145,10 +1768,10 @@ PyObject* wxPyCBH_callCallbackObj(const wxPyCallbackHelper& cbh, PyObject* argTu void wxPyCBH_delete(wxPyCallbackHelper* cbh) { if (cbh->m_incRef) { - wxPyBeginBlockThreads(); + bool blocked = wxPyBeginBlockThreads(); Py_XDECREF(cbh->m_self); Py_XDECREF(cbh->m_class); - wxPyEndBlockThreads(); + wxPyEndBlockThreads(blocked); } } @@ -1162,26 +1785,26 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh) { wxPyEvtSelfRef::wxPyEvtSelfRef() { //m_self = Py_None; // **** We don't do normal ref counting to prevent //Py_INCREF(m_self); // circular loops... - m_cloned = FALSE; + m_cloned = false; } wxPyEvtSelfRef::~wxPyEvtSelfRef() { - wxPyBeginBlockThreads(); + bool blocked = wxPyBeginBlockThreads(); if (m_cloned) Py_DECREF(m_self); - wxPyEndBlockThreads(); + wxPyEndBlockThreads(blocked); } void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) { - wxPyBeginBlockThreads(); + bool blocked = wxPyBeginBlockThreads(); if (m_cloned) Py_DECREF(m_self); m_self = self; if (clone) { Py_INCREF(m_self); - m_cloned = TRUE; + m_cloned = true; } - wxPyEndBlockThreads(); + wxPyEndBlockThreads(blocked); } PyObject* wxPyEvtSelfRef::GetSelf() const { @@ -1194,15 +1817,15 @@ 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) { } wxPyEvent::wxPyEvent(const wxPyEvent& evt) : wxEvent(evt) { - SetSelf(evt.m_self, TRUE); + SetSelf(evt.m_self, true); } @@ -1218,7 +1841,7 @@ wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id) wxPyCommandEvent::wxPyCommandEvent(const wxPyCommandEvent& evt) : wxCommandEvent(evt) { - SetSelf(evt.m_self, TRUE); + SetSelf(evt.m_self, true); } @@ -1228,84 +1851,47 @@ wxPyCommandEvent::~wxPyCommandEvent() { -//--------------------------------------------------------------------------- -//--------------------------------------------------------------------------- - - -wxPyTimer::wxPyTimer(PyObject* callback) { - func = callback; - Py_INCREF(func); -} - -wxPyTimer::~wxPyTimer() { - wxPyBeginBlockThreads(); - Py_DECREF(func); - wxPyEndBlockThreads(); -} - -void wxPyTimer::Notify() { - if (!func || func == Py_None) { - wxTimer::Notify(); - } - else { - wxPyBeginBlockThreads(); - - PyObject* result; - PyObject* args = Py_BuildValue("()"); - - result = PyEval_CallObject(func, args); - Py_DECREF(args); - if (result) { - Py_DECREF(result); - PyErr_Clear(); - } else { - PyErr_Print(); - } - - wxPyEndBlockThreads(); - } -} - - //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- -// Convert a wxList to a Python List +// Convert a wxList to a Python List, only works for lists of wxObjects -PyObject* wxPy_ConvertList(wxListBase* list, const char* className) { +PyObject* wxPy_ConvertList(wxListBase* listbase) { + wxList* list = (wxList*)listbase; // this is probably bad... PyObject* pyList; PyObject* pyObj; wxObject* wxObj; - wxNode* node = list->First(); + wxNode* node = list->GetFirst(); - wxPyBeginBlockThreads(); + bool blocked = wxPyBeginBlockThreads(); pyList = PyList_New(0); while (node) { - wxObj = node->Data(); - pyObj = wxPyMake_wxObject(wxObj); //wxPyConstructObject(wxObj, className); + wxObj = node->GetData(); + pyObj = wxPyMake_wxObject(wxObj,false); PyList_Append(pyList, pyObj); - node = node->Next(); + node = node->GetNext(); } - wxPyEndBlockThreads(); + wxPyEndBlockThreads(blocked); return pyList; } //---------------------------------------------------------------------- long wxPyGetWinHandle(wxWindow* win) { + #ifdef __WXMSW__ return (long)win->GetHandle(); #endif - // Find and return the actual X-Window. -#ifdef __WXGTK__ - if (win->m_wxwindow) { - GdkWindowPrivate* bwin = (GdkWindowPrivate*)GTK_PIZZA(win->m_wxwindow)->bin_window; - if (bwin) { - return (long)bwin->xwindow; - } - } +#if defined(__WXGTK__) || defined(__WXX11) + return (long)GetXWindow(win); #endif + +#ifdef __WXMAC__ + //return (long)MAC_WXHWND(win->MacGetTopLevelWindowRef()); + return (long)win->GetHandle(); +#endif + return 0; } @@ -1313,45 +1899,47 @@ long wxPyGetWinHandle(wxWindow* win) { // Some helper functions for typemaps in my_typemaps.i, so they won't be // 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 + wxString* target = NULL; + if (!PyString_Check(source) && !PyUnicode_Check(source)) { - PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + PyErr_SetString(PyExc_TypeError, "String or Unicode type required"); 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); + PyObject* uni = source; + if (PyString_Check(source)) { + uni = PyUnicode_FromEncodedObject(source, wxPyDefaultEncoding, "strict"); + if (PyErr_Occurred()) return NULL; } + target = new wxString(); + size_t len = PyUnicode_GET_SIZE(uni); + if (len) { + PyUnicode_AsWideChar((PyUnicodeObject*)uni, target->GetWriteBuf(len), len); + target->UngetWriteBuf(len); + } + + if (PyString_Check(source)) + Py_DECREF(uni); #else - char* tmpPtr; int tmpSize; - if (PyString_AsStringAndSize(source, &tmpPtr, &tmpSize) == -1) { - PyErr_SetString(PyExc_TypeError, "Unable to convert string"); - return NULL; + // Convert to a string object if it isn't already, then to wxString + PyObject* str = source; + if (PyUnicode_Check(source)) { + str = PyUnicode_AsEncodedString(source, wxPyDefaultEncoding, "strict"); + if (PyErr_Occurred()) return NULL; + } + else if (!PyString_Check(source)) { + str = PyObject_Str(source); + if (PyErr_Occurred()) return NULL; } + char* tmpPtr; int tmpSize; + PyString_AsStringAndSize(str, &tmpPtr, &tmpSize); target = new wxString(tmpPtr, tmpSize); + + if (!PyString_Check(source)) + Py_DECREF(str); #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; } @@ -1360,41 +1948,41 @@ wxString* wxString_in_helper(PyObject* source) { 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 + // Convert to a unicode object, if not already, then to a wxString + PyObject* uni = source; + if (!PyUnicode_Check(source)) { + uni = PyUnicode_FromEncodedObject(source, wxPyDefaultEncoding, "strict"); + if (PyErr_Occurred()) return wxEmptyString; // TODO: should we PyErr_Clear? + } + size_t len = PyUnicode_GET_SIZE(uni); + if (len) { + PyUnicode_AsWideChar((PyUnicodeObject*)uni, target.GetWriteBuf(len), len); + target.UngetWriteBuf(); + } + + if (!PyUnicode_Check(source)) + Py_DECREF(uni); +#else + // Convert to a string object if it isn't already, then to wxString + PyObject* str = source; 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); + str = PyUnicode_AsEncodedString(source, wxPyDefaultEncoding, "strict"); + if (PyErr_Occurred()) return wxEmptyString; // TODO: should we PyErr_Clear? + } + else if (!PyString_Check(source)) { + str = PyObject_Str(source); + if (PyErr_Occurred()) return wxEmptyString; // TODO: should we PyErr_Clear? } -#else char* tmpPtr; int tmpSize; - PyString_AsStringAndSize(source, &tmpPtr, &tmpSize); + PyString_AsStringAndSize(str, &tmpPtr, &tmpSize); target = wxString(tmpPtr, tmpSize); + + if (!PyString_Check(source)) + Py_DECREF(str); #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; } @@ -1404,7 +1992,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 @@ -1412,6 +2000,17 @@ PyObject* wx2PyString(const wxString& src) } + +void wxSetDefaultPyEncoding(const char* encoding) +{ + strncpy(wxPyDefaultEncoding, encoding, DEFAULTENCODING_SIZE); +} + +const char* wxGetDefaultPyEncoding() +{ + return wxPyDefaultEncoding; +} + //---------------------------------------------------------------------- @@ -1519,7 +2118,7 @@ static inline bool wxPointFromObjects(PyObject* o1, PyObject* o2, wxPoint* point point->y = (int)PyFloat_AS_DOUBLE(o2); return true; } - if (PyInstance_Check(o1) || PyInstance_Check(o2)) { + if (wxPySwigInstance_Check(o1) || wxPySwigInstance_Check(o2)) { // TODO: Why??? // Disallow instances because they can cause havok return false; } @@ -1577,9 +2176,9 @@ wxPoint* wxPoint_LIST_helper(PyObject* source, int *count) { goto error2; } } - else if (PyInstance_Check(o)) { + else if (wxPySwigInstance_Check(o)) { wxPoint* pt; - if (SWIG_GetPtrObj(o, (void **)&pt, "_wxPoint_p")) { + if (! wxPyConvertSwigPtr(o, (void **)&pt, wxT("wxPoint"))) { goto error2; } temp[x] = *pt; @@ -1609,7 +2208,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; @@ -1631,10 +2230,10 @@ wxBitmap** wxBitmap_LIST_helper(PyObject* source) { } for (int x=0; x