//
// Author: Robin Dunn
//
-// Created: 7/1/97
+// Created: 1-July-1997
// RCS-ID: $Id$
// Copyright: (c) 1998 by Total Control Software
// Licence: wxWindows license
#undef DEBUG
#include <Python.h>
-#include "helpers.h"
-#include "pyistream.h"
+#include "wx/wxPython/wxPython_int.h"
+#include "wx/wxPython/pyistream.h"
#ifdef __WXMSW__
#include <wx/msw/private.h>
#include <wx/gtk/win_gtk.h>
#endif
+#include <wx/clipbrd.h>
+#include <wx/mimetype.h>
+#include <wx/image.h>
+
//----------------------------------------------------------------------
#if PYTHON_API_VERSION <= 1007 && wxUSE_UNICODE
//----------------------------------------------------------------------
-#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 wxPyDoCleanup = False;
+bool wxPyDoingCleanup = False;
#ifdef WXP_WITH_THREAD
#endif
+static PyObject* wxPython_dict = NULL;
+static PyObject* wxPyAssertionError = NULL;
+
+PyObject* wxPyPtrTypeMap = NULL;
+
+
#ifdef __WXMSW__ // If building for win32...
//----------------------------------------------------------------------
// This gets run when the DLL is loaded. We just need to save a handle.
// the inatance has already been set.
if (! wxGetInstance())
wxSetInstance(hinstDLL);
- return TRUE;
+ return True;
}
#endif
// 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;
}
DeletePendingObjects();
bool initialized = wxTopLevelWindows.GetCount() != 0;
-#ifdef __WXGTK__
- m_initialized = initialized;
-#endif
-
if (initialized) {
if ( m_exitOnFrameDelete == Later ) {
m_exitOnFrameDelete = Yes;
}
+bool wxPyApp::OnInitGui() {
+ bool rval=True;
+ wxApp::OnInitGui(); // in this case always call the base class version
+ wxPyBeginBlockThreads();
+ 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 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;
+ 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
+}
+
+
+// This finishes the initialization of wxWindows and then calls the OnInit
+// that should be present in the derived (Python) class.
+void wxPyApp::_BootstrapApp()
+{
+ bool result;
+ PyObject* retval = NULL;
+ PyObject* pyint = NULL;
+
+
+ // Get any command-line args passed to this program from the sys module
+ int argc = 0;
+ char** argv = NULL;
+ wxPyBeginBlockThreads();
+ PyObject* sysargv = PySys_GetObject("argv");
+ if (sysargv != NULL) {
+ argc = PyList_Size(sysargv);
+ argv = new char*[argc+1];
+ int x;
+ for(x=0; x<argc; x++) {
+ PyObject *pyArg = PyList_GetItem(sysargv, x);
+ argv[x] = PyString_AsString(pyArg);
+ }
+ argv[argc] = NULL;
+ }
+ wxPyEndBlockThreads();
+
+ result = wxEntryStart(argc, argv);
+ delete [] argv;
+
+ wxPyBeginBlockThreads();
+ if (! result) {
+ PyErr_SetString(PyExc_SystemError, "wxEntryStart failed!");
+ goto error;
+ }
+
+ // The stock objects were all NULL when they were loaded into
+ // SWIG generated proxies, so re-init those now...
+ wxPy_ReinitStockObjects(False);
+
+ // It's now ok to generate exceptions for assertion errors.
+ wxPythonApp->SetStartupComplete(True);
+
+ // Call the Python wxApp's OnInit function
+ if (wxPyCBH_findCallback(m_myInst, "OnInit")) {
+ retval = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
+ 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();
+};
//---------------------------------------------------------------------
//----------------------------------------------------------------------
+#if 0
static char* wxPyCopyCString(const wxChar* src)
{
wxWX2MBbuf buff = (wxWX2MBbuf)wxConvCurrent->cWX2MB(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 wxc 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__
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; x<argc; x++) {
- PyObject *item = PyList_GetItem(sysargv, x);
-#if wxUSE_UNICODE
- if (PyUnicode_Check(item))
- argv[x] = wxPyCopyCString(PyUnicode_AS_UNICODE(item));
- else
-#endif
- argv[x] = wxPyCopyCString(PyString_AsString(item));
- }
- argv[argc] = NULL;
- }
-
- wxEntryStart(argc, argv);
- delete [] argv;
-}
-
-// Start the user application, user App's OnInit method is a parameter here
-PyObject* __wxStart(PyObject* /* self */, PyObject* args)
-{
- PyObject* onInitFunc = NULL;
- PyObject* arglist;
- PyObject* result;
- long bResult;
-
- if (!PyArg_ParseTuple(args, "O", &onInitFunc))
- return NULL;
-
- // This is the next part of the wxEntry functionality...
- int argc = 0;
- wxChar** argv = NULL;
- PyObject* sysargv = PySys_GetObject("argv");
- if (sysargv != NULL) {
- argc = PyList_Size(sysargv);
- argv = new wxChar*[argc+1];
- int x;
- for(x=0; x<argc; x++) {
- PyObject *pyArg = PyList_GetItem(sysargv, x);
-#if wxUSE_UNICODE
- if (PyUnicode_Check(pyArg))
- argv[x] = wxPyCopyWString(PyUnicode_AS_UNICODE(pyArg));
- else
+ // Save the current (main) thread state in our array
+ PyThreadState* tstate = wxPyBeginAllowThreads();
+ wxPyEndAllowThreads(tstate);
#endif
- argv[x] = wxPyCopyWString(PyString_AsString(pyArg));
- }
- argv[argc] = NULL;
- }
-
- wxPythonApp->argc = argc;
- wxPythonApp->argv = argv;
- wxEntryInitGui();
+ // Ensure that the build options in the DLL (or whatever) match this build
+ wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "wxPython");
- // 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;
+ // Init the stock objects to a non-NULL value so SWIG doesn't create them as None
+ wxPy_ReinitStockObjects(True);
}
-void __wxCleanup() {
- if (wxPyDoCleanup)
+
+void __wxPyCleanup() {
+ wxPyDoingCleanup = True;
+ if (wxPyDoCleanup) {
+ wxPyDoCleanup = False;
wxEntryCleanup();
+ }
#ifdef WXP_WITH_THREAD
delete wxPyTMutex;
wxPyTMutex = NULL;
}
-
-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;
}
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);
+
#ifdef __WXMOTIF__
#define wxPlatform "__WXMOTIF__"
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, "Platform", PyString_FromString(wxPlatform));
+ PyDict_SetItemString(wxPython_dict, "USE_UNICODE", PyInt_FromLong(wxUSE_UNICODE));
PyDict_SetItemString(wxPython_dict, "__WXDEBUG__", PyInt_FromLong(wxdebug));
- Py_INCREF(Py_None);
- return Py_None;
+ RETURN_NONE();
+}
+
+
+//---------------------------------------------------------------------------
+
+// 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 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(bool init)
+{
+ PyObject* obj;
+ PyObject* ptrobj;
+
+
+#define REINITOBJ(name, classname) \
+ if ( init ) { name = (classname*)0xC0C0C0C0; } else { \
+ obj = PyDict_GetItemString(wxPython_dict, dropwx(#name)); \
+ wxCHECK_RET(obj != NULL, wxT("Unable to find stock object for " #name)) \
+ wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance: " #name)); \
+ ptrobj = wxPyMakeSwigPtr((void*)name, wxT(#classname)); \
+ PyObject_SetAttrString(obj, "this", ptrobj); \
+ Py_DECREF(ptrobj); }
+
+#define REINITOBJ2(name, classname) \
+ if ( init ) { } else { \
+ obj = PyDict_GetItemString(wxPython_dict, dropwx(#name)); \
+ wxCHECK_RET(obj != NULL, wxT("Unable to find stock object for " #name)) \
+ wxCHECK_RET(wxPySwigInstance_Check(obj), wxT("Not a swig instance: " #name)); \
+ ptrobj = wxPyMakeSwigPtr((void*)&name, wxT(#classname)); \
+ 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);
+ 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);
+ self->m_obj = NULL;
+ wxPyEndBlockThreads();
+ }
}
void wxPyUserData_dtor(wxPyUserData* self) {
- wxPyBeginBlockThreads();
- Py_DECREF(self->m_obj);
- wxPyEndBlockThreads();
+ if (! wxPyDoingCleanup) {
+ wxPyBeginBlockThreads();
+ Py_DECREF(self->m_obj);
+ self->m_obj = NULL;
+ wxPyEndBlockThreads();
+ }
}
// 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();
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
+ if ( !wxPyDoingCleanup && self->m_obj->ob_refcnt > 1 ) {
+ // 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);
+ }
}
+
+ // m_obj is DECREF'd in the base class dtor...
wxPyEndBlockThreads();
}
+
//---------------------------------------------------------------------------
// Stuff used by OOR to find the right wxPython class type to return and to
// build it.
-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* 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, False);
if (target && isEvtHandler)
((wxEvtHandler*)source)->SetClientObject(new wxPyOORClientData(target));
} else {
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, False);
if (target != Py_None)
((wxSizer*)source)->SetClientObject(new wxPyOORClientData(target));
}
}
-
-//---------------------------------------------------------------------------
-
-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);
-}
-
-
//---------------------------------------------------------------------------
}
static PyThreadState* gs_shutdownTState;
+
static
PyThreadState* wxPyGetThreadState() {
if (wxPyTMutex == NULL) // Python is shutting down...
if (m_wxis)
return m_wxis->Eof();
else
- return TRUE;
+ return True;
}
wxPyInputStream::~wxPyInputStream() {
// 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());
}
}
// 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;
}
// 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;
}
// 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;
}
else
m_lasterror = wxSTREAM_READ_ERROR;
wxPyEndBlockThreads();
- m_lastcount = o;
return o;
}
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);
return OnSysTell();
}
+
off_t wxPyCBInputStream::OnSysTell() const {
wxPyBeginBlockThreads();
PyObject* arglist = Py_BuildValue("()");
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();
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();
}
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 */
// 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;
int wxPyCallbackHelper::callCallback(PyObject* argTuple) const {
PyObject* result;
- int retval = FALSE;
+ int retval = False;
result = callCallbackObj(argTuple);
if (result) { // Assumes an integer return type...
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() {
m_self = self;
if (clone) {
Py_INCREF(m_self);
- m_cloned = TRUE;
+ m_cloned = True;
}
wxPyEndBlockThreads();
}
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);
}
wxPyCommandEvent::wxPyCommandEvent(const wxPyCommandEvent& evt)
: wxCommandEvent(evt)
{
- SetSelf(evt.m_self, TRUE);
+ SetSelf(evt.m_self, True);
}
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-
-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();
pyList = PyList_New(0);
while (node) {
- wxObj = node->Data();
- pyObj = wxPyMake_wxObject(wxObj); //wxPyConstructObject(wxObj, className);
+ wxObj = node->GetData();
+ pyObj = wxPyMake_wxObject(wxObj);
PyList_Append(pyList, pyObj);
- node = node->Next();
+ node = node->GetNext();
}
wxPyEndBlockThreads();
return pyList;
// 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;
}
#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;
wxString Py2wxString(PyObject* source)
{
wxString target;
- bool doDecRef = FALSE;
+ 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;
+ doDecRef = True;
}
#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;
if (!PyString_Check(source)) {
// Convert to String if not one already...
source = PyObject_Str(source);
- doDecRef = TRUE;
+ doDecRef = True;
}
target = wxString(PyString_AS_STRING(source), PyString_GET_SIZE(source));
#endif
{
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
if (PyInt_Check(o1) && PyInt_Check(o2)) {
point->x = PyInt_AS_LONG(o1);
point->y = PyInt_AS_LONG(o2);
- return true;
+ return True;
}
if (PyFloat_Check(o1) && PyFloat_Check(o2)) {
point->x = (int)PyFloat_AS_DOUBLE(o1);
point->y = (int)PyFloat_AS_DOUBLE(o2);
- return true;
+ 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;
+ return False;
}
if (PyNumber_Check(o1) && PyNumber_Check(o2)) {
// I believe this excludes instances, so this should be safe without INCREFFing o1 and o2
point->x = PyInt_AsLong(o1);
point->y = PyInt_AsLong(o2);
- return true;
+ return True;
}
- return false;
+ return False;
}
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;
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;
}
for (int x=0; x<count; x++) {
PyObject* o = PyList_GetItem(source, x);
- if (PyInstance_Check(o)) {
+ if (wxPySwigInstance_Check(o)) {
wxBitmap* pt;
- if (SWIG_GetPtrObj(o, (void **) &pt,"_wxBitmap_p")) {
- PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
+ if (! wxPyConvertSwigPtr(o, (void **) &pt, wxT("wxBitmap"))) {
+ PyErr_SetString(PyExc_TypeError,"Expected wxBitmap.");
return NULL;
}
temp[x] = pt;
}
for (int x=0; x<count; x++) {
PyObject* o = PyList_GetItem(source, x);
- if (PyInstance_Check(o)) {
+ if (wxPySwigInstance_Check(o)) {
wxAcceleratorEntry* ae;
- if (SWIG_GetPtrObj(o, (void **) &ae,"_wxAcceleratorEntry_p")) {
- PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
+ if (! wxPyConvertSwigPtr(o, (void **) &ae, wxT("wxAcceleratorEntry"))) {
+ PyErr_SetString(PyExc_TypeError,"Expected wxAcceleratorEntry.");
return NULL;
}
temp[x] = *ae;
}
for (int x=0; x<count; x++) {
PyObject* o = PyList_GetItem(source, x);
- if (PyInstance_Check(o)) {
+ if (wxPySwigInstance_Check(o)) {
wxPen* pt;
- if (SWIG_GetPtrObj(o, (void **) &pt,"_wxPen_p")) {
+ if (! wxPyConvertSwigPtr(o, (void **)&pt, wxT("wxPen"))) {
delete temp;
- PyErr_SetString(PyExc_TypeError,"Expected _wxPen_p.");
+ PyErr_SetString(PyExc_TypeError,"Expected wxPen.");
return NULL;
}
temp[x] = pt;
}
-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;
if (!PySequence_Check(source) || PySequence_Length(source) != 2)
- return FALSE;
+ return False;
if (isFast) {
o1 = PySequence_Fast_GET_ITEM(source, 0);
Py_DECREF(o1);
Py_DECREF(o2);
}
- return TRUE;
+ return True;
}
-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;
if (!PySequence_Check(source) || PySequence_Length(source) != 4)
- return FALSE;
+ return False;
if (isFast) {
o1 = PySequence_Fast_GET_ITEM(source, 0);
Py_DECREF(o3);
Py_DECREF(o4);
}
- return TRUE;
+ return True;
}
//----------------------------------------------------------------------
-bool wxSize_helper(PyObject* source, wxSize** obj) {
-
- // If source is an object instance then it may already be the right type
- if (PyInstance_Check(source)) {
- wxSize* ptr;
- if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxSize_p"))
- goto error;
- *obj = ptr;
- return TRUE;
- }
- // otherwise a 2-tuple of integers is expected
- else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
- PyObject* o1 = PySequence_GetItem(source, 0);
- PyObject* o2 = PySequence_GetItem(source, 1);
- if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
- Py_DECREF(o1);
- Py_DECREF(o2);
- goto error;
- }
- **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
- Py_DECREF(o1);
- Py_DECREF(o2);
- return TRUE;
- }
-
- error:
- PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxSize object.");
- return FALSE;
+bool wxPySimple_typecheck(PyObject* source, const wxChar* classname, int seqLen)
+{
+ void* ptr;
+
+ if (wxPySwigInstance_Check(source) &&
+ wxPyConvertSwigPtr(source, (void **)&ptr, classname))
+ return True;
+
+ PyErr_Clear();
+ if (PySequence_Check(source) && PySequence_Length(source) == seqLen)
+ return True;
+
+ return False;
+}
+
+bool wxSize_helper(PyObject* source, wxSize** obj)
+{
+ return wxPyTwoIntItem_helper(source, obj, wxT("wxSize"));
}
-bool wxPoint_helper(PyObject* source, wxPoint** obj) {
- // If source is an object instance then it may already be the right type
- if (PyInstance_Check(source)) {
- wxPoint* ptr;
- if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxPoint_p"))
- goto error;
- *obj = ptr;
- return TRUE;
- }
- // otherwise a length-2 sequence of integers 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 = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
- Py_DECREF(o1);
- Py_DECREF(o2);
- return TRUE;
- }
- error:
- PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxPoint object.");
- return FALSE;
+bool wxPoint_helper(PyObject* source, wxPoint** obj)
+{
+ return wxPyTwoIntItem_helper(source, obj, wxT("wxPoint"));
}
bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
// If source is an object instance then it may already be the right type
- if (PyInstance_Check(source)) {
+ if (wxPySwigInstance_Check(source)) {
wxRealPoint* ptr;
- if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRealPoint_p"))
+ if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxRealPoint")))
goto error;
*obj = ptr;
- return TRUE;
+ return True;
}
// otherwise a 2-tuple of floats is expected
else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
**obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
Py_DECREF(o1);
Py_DECREF(o2);
- return TRUE;
+ return True;
}
error:
PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object.");
- return FALSE;
+ return False;
}
-
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)) {
+ if (wxPySwigInstance_Check(source)) {
wxRect* ptr;
- if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRect_p"))
+ if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxRect")))
goto error;
*obj = ptr;
- return TRUE;
+ return True;
}
// otherwise a 4-tuple of integers is expected
else if (PySequence_Check(source) && PyObject_Length(source) == 4) {
Py_DECREF(o2);
Py_DECREF(o3);
Py_DECREF(o4);
- return TRUE;
+ return True;
}
error:
PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object.");
- return FALSE;
+ return False;
}
bool wxColour_helper(PyObject* source, wxColour** obj) {
// If source is an object instance then it may already be the right type
- if (PyInstance_Check(source)) {
+ if (wxPySwigInstance_Check(source)) {
wxColour* ptr;
- if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxColour_p"))
+ if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxColour")))
goto error;
*obj = ptr;
- return TRUE;
+ 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;
spec.Mid(5,2).ToLong(&blue, 16);
**obj = wxColour(red, green, blue);
- return TRUE;
+ return True;
}
else { // it's a colour name
**obj = wxColour(spec);
- return TRUE;
+ return True;
}
}
+ // last chance: 3-tuple of integers is expected
+ else if (PySequence_Check(source) && PyObject_Length(source) == 3) {
+ PyObject* o1 = PySequence_GetItem(source, 0);
+ PyObject* o2 = PySequence_GetItem(source, 1);
+ PyObject* o3 = PySequence_GetItem(source, 2);
+ if (!PyNumber_Check(o1) || !PyNumber_Check(o2) || !PyNumber_Check(o3)) {
+ Py_DECREF(o1);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ goto error;
+ }
+ **obj = wxColour(PyInt_AsLong(o1), PyInt_AsLong(o2), PyInt_AsLong(o3));
+ Py_DECREF(o1);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ return True;
+ }
error:
PyErr_SetString(PyExc_TypeError,
- "Expected a wxColour object or a string containing a colour "
- "name or '#RRGGBB'.");
- return FALSE;
+ "Expected a wxColour object or a string containing a colour name or '#RRGGBB'.");
+ return False;
+}
+
+
+bool wxColour_typecheck(PyObject* source) {
+
+ if (wxPySimple_typecheck(source, wxT("wxColour"), 3))
+ return True;
+
+ if (PyString_Check(source) || PyUnicode_Check(source))
+ return True;
+
+ return False;
+}
+
+
+
+bool wxPoint2D_helper(PyObject* source, wxPoint2D** obj) {
+ // If source is an object instance then it may already be the right type
+ if (wxPySwigInstance_Check(source)) {
+ wxPoint2D* ptr;
+ if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxPoint2D")))
+ 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 floats, not numbers -- but that would break code.
+ if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
+ Py_DECREF(o1);
+ Py_DECREF(o2);
+ goto error;
+ }
+ **obj = wxPoint2D(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 wxPoint2D object.");
+ return False;
}
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
projects / wxWidgets.git / blobdiff