X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0d6f9504aef08d44d8b20df4419f4db9150ef073..e02c03a42ea85be1e908962c8a344fb2553e7c3e:/utils/wxPython/src/helpers.cpp diff --git a/utils/wxPython/src/helpers.cpp b/utils/wxPython/src/helpers.cpp index 6649ed56c8..a512d7c07c 100644 --- a/utils/wxPython/src/helpers.cpp +++ b/utils/wxPython/src/helpers.cpp @@ -10,23 +10,31 @@ // Licence: wxWindows license ///////////////////////////////////////////////////////////////////////////// +#include // get the correct definition of NULL + +#undef DEBUG +#include +#include "helpers.h" + #ifdef __WXMSW__ -#include +#include #undef FindWindow #undef GetCharWidth #undef LoadAccelerators +#undef GetClassInfo +#undef GetClassName #endif -#undef DEBUG -#include -#include "helpers.h" - #ifdef __WXGTK__ -#ifdef USE_GDK_IMLIB -#include "gdk_imlib/gdk_imlib.h" -#endif +#include +#include +#include +//#include +//#include +//#include #endif + //--------------------------------------------------------------------------- //wxHashTable* wxPyWindows = NULL; @@ -39,18 +47,17 @@ wxString wxPyEmptyStr(""); #ifdef __WXMSW__ // If building for win32... -extern HINSTANCE wxhInstance; - //---------------------------------------------------------------------- // This gets run when the DLL is loaded. We just need to save a handle. //---------------------------------------------------------------------- + BOOL WINAPI DllMain( HINSTANCE hinstDLL, // handle to DLL module DWORD fdwReason, // reason for calling function LPVOID lpvReserved // reserved ) { - wxhInstance = hinstDLL; + wxSetInstance(hinstDLL); return 1; } #endif @@ -62,48 +69,52 @@ BOOL WINAPI DllMain( wxPyApp *wxPythonApp = NULL; // Global instance of application object +wxPyApp::wxPyApp() { +// printf("**** ctor\n"); +} + +wxPyApp::~wxPyApp() { +// printf("**** dtor\n"); +} + + // This one isn't acutally called... See __wxStart() bool wxPyApp::OnInit(void) { - return false; + return FALSE; } int wxPyApp::MainLoop(void) { int retval = wxApp::MainLoop(); - AfterMainLoop(); +//# AfterMainLoop(); + wxPythonApp->OnExit(); //# return retval; } -void wxPyApp::AfterMainLoop(void) { - // more stuff from wxEntry... -#ifdef __WXMSW__ - if (wxPythonApp->GetTopWindow()) { - // Forcibly delete the window. - if (wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxFrame)) || - wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxDialog))) { +//# void wxPyApp::AfterMainLoop(void) { +// // more stuff from wxEntry... - wxPythonApp->GetTopWindow()->Close(TRUE); - wxPythonApp->DeletePendingObjects(); - } - else { - delete wxPythonApp->GetTopWindow(); - wxPythonApp->SetTopWindow(NULL); - } - } -#endif -#ifdef __WXGTK__ - wxPythonApp->DeletePendingObjects(); -#endif +// if (wxPythonApp->GetTopWindow()) { +// // Forcibly delete the window. +// if (wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxFrame)) || +// wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxDialog))) { - wxPythonApp->OnExit(); -#ifdef __WXMSW__ - wxApp::CleanUp(); -#endif -#ifdef __WXGTK__ - wxApp::CommonCleanUp(); -#endif - delete wxPythonApp; -} +// wxPythonApp->GetTopWindow()->Close(TRUE); +// wxPythonApp->DeletePendingObjects(); +// } +// else { +// delete wxPythonApp->GetTopWindow(); +// wxPythonApp->SetTopWindow(NULL); +// } +// } +// #ifdef __WXGTK__ +// wxPythonApp->DeletePendingObjects(); +// #endif + +// wxPythonApp->OnExit(); +// wxApp::CleanUp(); +// // delete wxPythonApp; +// } //--------------------------------------------------------------------- @@ -112,10 +123,14 @@ void wxPyApp::AfterMainLoop(void) { // This is where we pick up the first part of the wxEntry functionality... -// The rest is in __wxStart and AfterMainLoop. Thi function is called when -// wxpc is imported. (Before there is a wxApp object.) +// The rest is in __wxStart and AfterMainLoop. This function is called when +// wxcmodule is imported. (Before there is a wxApp object.) void __wxPreStart() { +#ifdef WXP_WITH_THREAD + PyEval_InitThreads(); +#endif + // Bail out if there is already windows created. This means that the // toolkit has already been initialized, as in embedding wxPython in // a C++ wxWindows app. @@ -123,11 +138,10 @@ void __wxPreStart() return; #ifdef __WXMSW__ - wxApp::Initialize((WXHINSTANCE)wxhInstance); + wxApp::Initialize(); #endif -#ifdef __WXGTK__ - wxClassInfo::InitializeClasses(); +#ifdef __WXGTK__ PyObject* sysargv = PySys_GetObject("argv"); int argc = PyList_Size(sysargv); char** argv = new char*[argc+1]; @@ -136,24 +150,29 @@ void __wxPreStart() argv[x] = PyString_AsString(PyList_GetItem(sysargv, x)); argv[argc] = NULL; + gtk_set_locale(); +#if wxUSE_WCHAR_T + if (!wxOKlibc()) wxConvCurrent = &wxConvLocal; +#else + if (!wxOKlibc()) wxConvCurrent = (wxMBConv*) NULL; +#endif gtk_init( &argc, &argv ); + wxSetDetectableAutoRepeat( TRUE ); delete [] argv; -#ifdef USE_GDK_IMLIB - gdk_imlib_init(); - gtk_widget_push_visual(gdk_imlib_get_visual()); - gtk_widget_push_colormap(gdk_imlib_get_colormap()); -#endif - - wxApp::CommonInit(); + wxApp::Initialize(); // may return FALSE. Should we check? #endif } - +#ifdef WXP_WITH_THREAD +PyThreadState* wxPyEventThreadState = NULL; +#endif static char* __nullArgv[1] = { 0 }; + + // Start the user application, user App's OnInit method is a parameter here PyObject* __wxStart(PyObject* /* self */, PyObject* args) { @@ -162,6 +181,9 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args) PyObject* result; long bResult; +#ifdef WXP_WITH_THREAD + wxPyEventThreadState = PyThreadState_Get(); +#endif if (!PyArg_ParseTuple(args, "O", &onInitFunc)) return NULL; @@ -174,16 +196,15 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args) // This is the next part of the wxEntry functionality... wxPythonApp->argc = 0; - wxPythonApp->argv = __nullArgv; + wxPythonApp->argv = NULL; wxPythonApp->OnInitGui(); // Call the Python App's OnInit function arglist = PyTuple_New(0); result = PyEval_CallObject(onInitFunc, arglist); - if (!result) { - PyErr_Print(); - exit(1); + if (!result) { // an exception was raised. + return NULL; } if (! PyInt_Check(result)) { @@ -192,15 +213,7 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args) } bResult = PyInt_AS_LONG(result); if (! bResult) { - wxPythonApp->DeletePendingObjects(); - wxPythonApp->OnExit(); -#ifdef __WXMSW__ - wxApp::CleanUp(); -#endif -#ifdef __WXGTK__ - wxApp::CommonCleanUp(); -#endif - PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting..."); + PyErr_SetString(PyExc_SystemExit, "OnInit returned FALSE, exiting..."); return NULL; } @@ -252,11 +265,8 @@ PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args) //--------------------------------------------------------------------------- - -static -PyObject* wxPyConstructObject(void* ptr, char* className) -{ - char buff[64]; // should be big enough... +PyObject* wxPyConstructObject(void* ptr, const char* className) { + char buff[64]; // should always be big enough... char swigptr[64]; sprintf(buff, "_%s_p", className); @@ -276,6 +286,69 @@ PyObject* wxPyConstructObject(void* ptr, char* className) return obj; } +//--------------------------------------------------------------------------- + +static unsigned int _wxPyNestCount = 0; + +static PyThreadState* myPyThreadState_Get() { + PyThreadState* current; + current = PyThreadState_Swap(NULL); + PyThreadState_Swap(current); + return current; +} + + +HELPEREXPORT bool wxPyRestoreThread() { + // NOTE: The Python API docs state that if a thread already has the + // interpreter lock and calls PyEval_RestoreThread again a deadlock + // occurs, so I put in this code as a guard condition since there are + // many possibilites for nested events and callbacks in wxPython. If + // The current thread is our thread, then we can assume that we + // already have the lock. (I hope!) + // +#ifdef WXP_WITH_THREAD + _wxPyNestCount += 1; + if (wxPyEventThreadState != myPyThreadState_Get()) { + PyEval_RestoreThread(wxPyEventThreadState); + return TRUE; + } + else +#endif + return FALSE; +} + + +HELPEREXPORT void wxPySaveThread(bool doSave) { +#ifdef WXP_WITH_THREAD + if (doSave) { + wxPyEventThreadState = PyEval_SaveThread(); + } + _wxPyNestCount -= 1; +#endif +} + +//--------------------------------------------------------------------------- + + +IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject); + +wxPyCallback::wxPyCallback(PyObject* func) { + m_func = func; + Py_INCREF(m_func); +} + +wxPyCallback::wxPyCallback(const wxPyCallback& other) { + m_func = other.m_func; + Py_INCREF(m_func); +} + +wxPyCallback::~wxPyCallback() { + bool doSave = wxPyRestoreThread(); + Py_DECREF(m_func); + wxPySaveThread(doSave); +} + + // This function is used for all events destined for Python event handlers. void wxPyCallback::EventThunker(wxEvent& event) { @@ -285,12 +358,20 @@ void wxPyCallback::EventThunker(wxEvent& event) { PyObject* arg; PyObject* tuple; - arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName()); + + bool doSave = wxPyRestoreThread(); + wxString className = event.GetClassInfo()->GetClassName(); + + if (className == "wxPyEvent") + arg = ((wxPyEvent*)&event)->GetSelf(); + else if (className == "wxPyCommandEvent") + arg = ((wxPyCommandEvent*)&event)->GetSelf(); + else + arg = wxPyConstructObject((void*)&event, className); tuple = PyTuple_New(1); PyTuple_SET_ITEM(tuple, 0, arg); result = PyEval_CallObject(func, tuple); - Py_DECREF(arg); Py_DECREF(tuple); if (result) { Py_DECREF(result); @@ -298,46 +379,154 @@ void wxPyCallback::EventThunker(wxEvent& event) { } else { PyErr_Print(); } + wxPySaveThread(doSave); } -//--------------------------------------------------------------------------- +//---------------------------------------------------------------------- -wxPyMenu::wxPyMenu(const wxString& title, PyObject* _func) - : wxMenu(title, (wxFunction)(func ? MenuCallback : NULL)), func(0) { +wxPyCallbackHelper::wxPyCallbackHelper() { + m_self = NULL; + m_lastFound = NULL; + m_incRef = FALSE; +} - if (_func) { - func = _func; - Py_INCREF(func); - } + +wxPyCallbackHelper::~wxPyCallbackHelper() { + bool doSave = wxPyRestoreThread(); + if (m_incRef) + Py_XDECREF(m_self); + wxPySaveThread(doSave); +} + +wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) { + m_lastFound = NULL; + m_self = other.m_self; + if (m_self) + Py_INCREF(m_self); +} + + +void wxPyCallbackHelper::setSelf(PyObject* self, int incref) { + m_self = self; + m_incRef = incref; + if (incref) + Py_INCREF(m_self); } -wxPyMenu::~wxPyMenu() { - if (func) - Py_DECREF(func); + +bool wxPyCallbackHelper::findCallback(const wxString& name) { + m_lastFound = NULL; + if (m_self && PyObject_HasAttrString(m_self, (char*)name.c_str())) + m_lastFound = PyObject_GetAttrString(m_self, (char*)name.c_str()); + + return m_lastFound != NULL; } -void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) { - PyObject* evtobj = wxPyConstructObject((void*)&evt, "wxCommandEvent"); - PyObject* menuobj = wxPyConstructObject((void*)&menu, "wxMenu"); - if (PyErr_Occurred()) { - // bail out if a problem +int wxPyCallbackHelper::callCallback(PyObject* argTuple) { + PyObject* result; + int retval = FALSE; + + result = callCallbackObj(argTuple); + if (result) { // Assumes an integer return type... + retval = PyInt_AsLong(result); + Py_DECREF(result); + PyErr_Clear(); // forget about it if it's not... + } + return retval; +} + +// Invoke the Python callable object, returning the raw PyObject return +// value. Caller should DECREF the return value and also call PyEval_SaveThread. +PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) { + PyObject* result; + + result = PyEval_CallObject(m_lastFound, argTuple); + Py_DECREF(argTuple); + if (!result) { PyErr_Print(); - return; } - // Now call the callback... - PyObject* func = ((wxPyMenu*)&menu)->func; - PyObject* args = Py_BuildValue("(OO)", menuobj, evtobj); - PyObject* res = PyEval_CallObject(func, args); - Py_DECREF(args); - Py_DECREF(res); - Py_DECREF(evtobj); - Py_DECREF(menuobj); + return result; +} + + + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +// These classes can be derived from in Python and passed through the event +// system without loosing anything. They do this by keeping a reference to +// themselves and some special case handling in wxPyCallback::EventThunker. + + +wxPyEvtSelfRef::wxPyEvtSelfRef() { + //m_self = Py_None; // **** We don't do normal ref counting to prevent + //Py_INCREF(m_self); // circular loops... + m_cloned = FALSE; +} + +wxPyEvtSelfRef::~wxPyEvtSelfRef() { + bool doSave = wxPyRestoreThread(); + if (m_cloned) + Py_DECREF(m_self); + wxPySaveThread(doSave); +} + +void wxPyEvtSelfRef::SetSelf(PyObject* self, bool clone) { + bool doSave = wxPyRestoreThread(); + if (m_cloned) + Py_DECREF(m_self); + m_self = self; + if (clone) { + Py_INCREF(m_self); + m_cloned = TRUE; + } + wxPySaveThread(doSave); +} + +PyObject* wxPyEvtSelfRef::GetSelf() const { + Py_INCREF(m_self); + return m_self; +} + + +wxPyEvent::wxPyEvent(int id) + : wxEvent(id) { +} + +wxPyEvent::~wxPyEvent() { } +// This one is so the event object can be Cloned... +void wxPyEvent::CopyObject(wxObject& dest) const { + wxEvent::CopyObject(dest); + ((wxPyEvent*)&dest)->SetSelf(m_self, TRUE); +} + + +IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxEvent); + + +wxPyCommandEvent::wxPyCommandEvent(wxEventType commandType, int id) + : wxCommandEvent(commandType, id) { +} + +wxPyCommandEvent::~wxPyCommandEvent() { +} + +void wxPyCommandEvent::CopyObject(wxObject& dest) const { + wxCommandEvent::CopyObject(dest); + ((wxPyCommandEvent*)&dest)->SetSelf(m_self, TRUE); +} + + +IMPLEMENT_DYNAMIC_CLASS(wxPyCommandEvent, wxCommandEvent); + + //--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + wxPyTimer::wxPyTimer(PyObject* callback) { func = callback; @@ -345,10 +534,14 @@ wxPyTimer::wxPyTimer(PyObject* callback) { } wxPyTimer::~wxPyTimer() { + bool doSave = wxPyRestoreThread(); Py_DECREF(func); + wxPySaveThread(doSave); } void wxPyTimer::Notify() { + bool doSave = wxPyRestoreThread(); + PyObject* result; PyObject* args = Py_BuildValue("()"); @@ -360,15 +553,78 @@ void wxPyTimer::Notify() { } else { PyErr_Print(); } + wxPySaveThread(doSave); } +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +// Convert a wxList to a Python List + +PyObject* wxPy_ConvertList(wxListBase* list, const char* className) { + PyObject* pyList; + PyObject* pyObj; + wxObject* wxObj; + wxNode* node = list->First(); + + bool doSave = wxPyRestoreThread(); + pyList = PyList_New(0); + while (node) { + wxObj = node->Data(); + pyObj = wxPyConstructObject(wxObj, className); + PyList_Append(pyList, pyObj); + node = node->Next(); + } + wxPySaveThread(doSave); + 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; + } + } +#endif + return 0; +} + //---------------------------------------------------------------------- // Some helper functions for typemaps in my_typemaps.i, so they won't be -// imcluded in every file... +// included in every file... + + +byte* byte_LIST_helper(PyObject* source) { + if (!PyList_Check(source)) { + PyErr_SetString(PyExc_TypeError, "Expected a list object."); + return NULL; + } + int count = PyList_Size(source); + byte* temp = new byte[count]; + if (! temp) { + PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array"); + return NULL; + } + for (int x=0; xargc; -// char** argv = wxPythonApp->argv; -// for (int i = 1; i < argc; i++) { -// if (strncmp(argv[i], "wxpstderr=", 10) == 0) -// stderrfilename = argv[i]+10; -// else { -// PyList_Append(argvList, PyString_FromString(argv[i])); -// if (!script) -// script = argv[i]; -// pyargc++; -// } -// } +bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) { -// PySys_SetObject("argv", argvList); + // If source is an object instance then it may already be the right type + if (PyInstance_Check(source)) { + wxRealPoint* ptr; + if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRealPoint_p")) + goto error; + *obj = ptr; + return TRUE; + } + // otherwise a 2-tuple of floats is expected + else if (PySequence_Check(source) && PyObject_Length(source) == 2) { + PyObject* o1 = PySequence_GetItem(source, 0); + PyObject* o2 = PySequence_GetItem(source, 1); + **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2)); + return TRUE; + } + + error: + PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object."); + return FALSE; +} -//#if 1 -// char buf[256]; -//// //PyRun_SimpleString("import sys; sys.stdout=open('wxpstdout.log','w')"); -// sprintf(buf, "import sys; sys.stdout=sys.stderr=open('%s','w')", stderrfilename); -// PyRun_SimpleString(buf); -//#endif -// initwxPythonc(); -// if (script) { -// FILE *fp = fopen(script, "r"); -// if (fp) { -// PyRun_SimpleFile(fp, script);// This returns after wxpApp constructor -// fclose(fp); -// } -// else { -// char msg[256]; -// sprintf(msg, "Cannot open %s", script); -// wxMessageBox(msg); -// } -// } -// else -// PyRun_SimpleString("import wxpide"); -// return 0; -//} +bool wxRect_helper(PyObject* source, wxRect** obj) { + + // If source is an object instance then it may already be the right type + if (PyInstance_Check(source)) { + wxRect* ptr; + if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRect_p")) + goto error; + *obj = ptr; + return TRUE; + } + // otherwise a 4-tuple of integers is expected + else if (PySequence_Check(source) && PyObject_Length(source) == 4) { + PyObject* o1 = PySequence_GetItem(source, 0); + PyObject* o2 = PySequence_GetItem(source, 1); + PyObject* o3 = PySequence_GetItem(source, 2); + PyObject* o4 = PySequence_GetItem(source, 3); + **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2), + PyInt_AsLong(o3), PyInt_AsLong(o4)); + return TRUE; + } + + error: + PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object."); + return FALSE; +} -//#endif //---------------------------------------------------------------------- +//---------------------------------------------------------------------- +//---------------------------------------------------------------------- + + -///////////////////////////////////////////////////////////////////////////// -// -// $Log$ -// Revision 1.8 1998/08/27 21:59:08 RD -// Some chicken-and-egg problems solved for wxPython on wxGTK -// -// Revision 1.7 1998/08/27 00:00:26 RD -// - more tweaks -// - have discovered some problems but not yet discovered solutions... -// -// Revision 1.6 1998/08/18 21:54:12 RD -// -// ifdef out some wxGTK specific code -// -// Revision 1.5 1998/08/18 19:48:17 RD -// more wxGTK compatibility things. -// -// It builds now but there are serious runtime problems... -// -// Revision 1.4 1998/08/16 04:31:06 RD -// More wxGTK work. -// -// Revision 1.3 1998/08/15 07:36:36 RD -// - Moved the header in the .i files out of the code that gets put into -// the .cpp files. It caused CVS conflicts because of the RCS ID being -// different each time. -// -// - A few minor fixes. -// -// Revision 1.2 1998/08/14 23:36:36 RD -// Beginings of wxGTK compatibility -// -// Revision 1.1 1998/08/09 08:25:51 RD -// Initial version -// -//