GIT_REPOSITORIES/LPP/PythonQt Commit - r161:87322f2ddb44

merged contributions from https://github.com/commontk/PythonQt/compare/svn-mirror...patched...

florianlink -

r161:87322f2ddb44

parent child

Context file:

r161:87322f2ddb44

Collapse all files

src/PythonQt.cpp +61 -1

             #include "PythonQtMethodInfo.h"
             #include "PythonQtSignalReceiver.h"
             #include "PythonQtConversion.h"
+            #include "PythonQtStdIn.h"
             #include "PythonQtStdOut.h"
             #include "PythonQtCppWrapperFactory.h"
             #include "PythonQtVariants.h"
               }
             }
+            PythonQt* PythonQt::self() { return _self; }
             PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)
             {
               _p = new PythonQtPrivate;
               _p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");
               if ((flags & PythonAlreadyInitialized) == 0) {
-                Py_SetProgramName("PythonQt");
+                Py_SetProgramName(const_cast<char*>("PythonQt"));
                 if (flags & IgnoreSiteModule) {
                   // this prevents the automatic importing of Python site files
                   Py_NoSiteFlag = 1;
               }
               Py_INCREF(&PythonQtStdOutRedirectType);
+              // add our own python object types for redirection of stdin
+              if (PyType_Ready(&PythonQtStdInRedirectType) < 0) {
+                std::cerr << "could not initialize PythonQtStdInRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
+              }
+              Py_INCREF(&PythonQtStdInRedirectType);
               initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);
               _p->setupSharedLibrarySuffixes();
               PythonQtMethodInfo::cleanupCachedMethodInfos();
             }
+            void PythonQt::setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData)
+            {
+              if (!callback)
+                {
+                std::cerr << "PythonQt::setRedirectStdInCallback - callback parameter is NULL !" << std::endl;
+                return;
+                }
+              PythonQtObjectPtr sys;
+              PythonQtObjectPtr in;
+              sys.setNewRef(PyImport_ImportModule("sys"));
+              // Backup original 'sys.stdin' if not yet done
+              PyRun_SimpleString("if not hasattr(sys, 'pythonqt_original_stdin'):"
+                                 "sys.pythonqt_original_stdin = sys.stdin");
+              in = PythonQtStdInRedirectType.tp_new(&PythonQtStdInRedirectType, NULL, NULL);
+              ((PythonQtStdInRedirect*)in.object())->_cb = callback;
+              ((PythonQtStdInRedirect*)in.object())->_callData = callbackData;
+              // replace the built in file objects with our own objects
+              PyModule_AddObject(sys, "stdin", in);
+              // Backup custom 'stdin' into 'pythonqt_stdin'
+              PyRun_SimpleString("sys.pythonqt_stdin = sys.stdin");
+            }
+            void PythonQt::setRedirectStdInCallbackEnabled(bool enabled)
+            {
+              if (enabled)
+                {
+                PyRun_SimpleString("if hasattr(sys, 'pythonqt_stdin'):"
+                                   "sys.stdin = sys.pythonqt_stdin");
+                }
+              else
+                {
+                PyRun_SimpleString("if hasattr(sys,'pythonqt_original_stdin'):"
+                                   "sys.stdin = sys.pythonqt_original_stdin");
+                }
+            }
             PythonQtImportFileInterface* PythonQt::importInterface()
             {
               return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
                   // if we a have a QObject wrapper and the metaobjects do not match, set the metaobject again!
                   info->setMetaObject(wrapper->metaObject());
                 }
+                // TODO XXX: delegate wrapping via CB here (pass name and ptr)
                 wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
                 //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               } else {
             void PythonQt::stdOutRedirectCB(const QString& str)
             {
+              if (!PythonQt::self()) {
+                std::cout << str.toLatin1().data() << std::endl;
+                return;
+              }
               emit PythonQt::self()->pythonStdOut(str);
             }
             void PythonQt::stdErrRedirectCB(const QString& str)
             {
+              if (!PythonQt::self()) {
+                std::cerr << str.toLatin1().data() << std::endl;
+                return;
+              }
               emit PythonQt::self()->pythonStdErr(str);
             }

src/PythonQt.h +22 -3

             #include "PythonQtClassWrapper.h"
             #include "PythonQtSlot.h"
             #include "PythonQtObjectPtr.h"
+            #include "PythonQtStdIn.h"
             #include <QObject>
             #include <QVariant>
             #include <QList>
             typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* wrapper);
-            template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) { ((T*)object)->_wrapper = wrapper; };
+            template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) {
+              (reinterpret_cast<T*>(object))->_wrapper = wrapper;
+            }
             //! returns the offset that needs to be added to upcast an object of type T1 to T2
             template<class T1, class T2> int PythonQtUpcastingOffset() {
-              return (((char*)(static_cast<T2*>(reinterpret_cast<T1*>(0x100)))) - ((char*)reinterpret_cast<T1*>(0x100)));
+              return ((reinterpret_cast<char*>(static_cast<T2*>(reinterpret_cast<T1*>(0x100))))
+                      - (reinterpret_cast<char*>(reinterpret_cast<T1*>(0x100))));
             }
             //! callback to create a QObject lazily
               static void cleanup();
               //! get the singleton instance
-              static PythonQt* self() { return _self; }
+              static PythonQt* self();
               //@}
                 CallOverloads
               };
+              //---------------------------------------------------------------------------
+              //! \name Standard input handling
+              //@{
+              //! Overwrite default handling of stdin using a custom callback. It internally backup
+              //! the original 'sys.stdin' into 'sys.pythonqt_original_stdin'
+              void setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData = 0);
+              //! Enable or disable stdin custom callback. It resets 'sys.stdin' using either 'sys.pythonqt_stdin'
+              //! or 'sys.pythonqt_original_stdin'
+              void setRedirectStdInCallbackEnabled(bool enabled);
+              //@}
               //---------------------------------------------------------------------------
               //! \name Modules
               //@{

src/PythonQtClassWrapper.h +1 -1

             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"

src/PythonQtConversion.cpp +3 -10

                  } else if (info.name == "PyObject") {
                    // handle low level PyObject directly
                    PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, obj, ptr);
-                 } else if (obj == Py_None) {
+                 // TODO XXX: pass obj and name and add when it returns a pointer
+                 else if (obj == Py_None) {
                    // None is treated as a NULL ptr
                    PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
                  } else {
               if (val->ob_type == &PyString_Type) {
                 r = QString(PyString_AS_STRING(val));
               } else if (PyUnicode_Check(val)) {
-            #ifdef WIN32
-                r = QString::fromUtf16(PyUnicode_AS_UNICODE(val));
-            #else
                 PyObject *ptmp = PyUnicode_AsUTF8String(val);
                 if(ptmp) {
                   r = QString::fromUtf8(PyString_AS_STRING(ptmp));
                   Py_DECREF(ptmp);
                 }
-            #endif
               } else if (!strict) {
                 // EXTRA: could also use _Unicode, but why should we?
                 PyObject* str =  PyObject_Str(val);
               if (str.isNull()) {
                 return PyString_FromString("");
               } else {
-            #ifdef WIN32
-                //    return PyString_FromString(str.toLatin1().data());
-                return PyUnicode_FromUnicode(str.utf16(), str.length());
-            #else
                 return PyUnicode_DecodeUTF16((const char*)str.utf16(), str.length()*2, NULL, NULL);
-            #endif
               }
             }

src/PythonQtImporter.cpp +2 -2

               mod = Py_InitModule4("PythonQtImport", NULL, mlabimport_doc,
                        NULL, PYTHON_API_VERSION);
-              PythonQtImportError = PyErr_NewException("PythonQtImport.PythonQtImportError",
+              PythonQtImportError = PyErr_NewException(const_cast<char*>("PythonQtImport.PythonQtImportError"),
                           PyExc_ImportError, NULL);
               if (PythonQtImportError == NULL)
                 return;
               // set our importer into the path_hooks to handle all path on sys.path
               PyObject* classobj = PyDict_GetItemString(PyModule_GetDict(mod), "PythonQtImporter");
-              PyObject* path_hooks = PySys_GetObject("path_hooks");
+              PyObject* path_hooks = PySys_GetObject(const_cast<char*>("path_hooks"));
               PyList_Append(path_hooks, classobj);
             #ifndef WIN32

src/PythonQtImporter.h +2 -1

             */
             //----------------------------------------------------------------------------------
-            #include "Python.h"
+            #include "PythonQtPythonInclude.h"
             #include "structmember.h"
             #include "osdefs.h"
             #include "marshal.h"

src/PythonQtInstanceWrapper.h +2 -1

             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include <QPointer>
             PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self);
             #endif

src/PythonQtObjectPtr.cpp +28 -1

@@ -41,6 +41,25
41		41
42	#include <PythonQt.h>	42	#include <PythonQt.h>
43		43
		44	PythonQtObjectPtr::PythonQtObjectPtr(PyObject* o)
		45	{
		46	_object = o;
		47	if (o) Py_INCREF(_object);
		48	}
		49
		50	PythonQtObjectPtr::~PythonQtObjectPtr()
		51	{
		52	if (_object) Py_DECREF(_object);
		53	}
		54
		55	void PythonQtObjectPtr::setNewRef(PyObject* o)
		56	{
		57	if (o != _object) {
		58	if (_object) Py_DECREF(_object);
		59	_object = o;
		60	}
		61	}
		62
44	QVariant PythonQtObjectPtr::evalScript(const QString& script, int start)	63	QVariant PythonQtObjectPtr::evalScript(const QString& script, int start)
45	{	64	{
46	return PythonQt::self()->evalScript(_object, script, start);	65	return PythonQt::self()->evalScript(_object, script, start);
@@ -96,6 +115,14 bool PythonQtObjectPtr::fromVariant(const QVariant& variant)
96	else {	115	else {
97	setObject(0);	116	setObject(0);
98	return false;	117	return false;
		118	}
		119	}
		120
		121	void PythonQtObjectPtr::setObject(PyObject* o)
		122	{
		123	if (o != _object) {
		124	if (_object) Py_DECREF(_object);
		125	_object = o;
		126	if (_object) Py_INCREF(_object);
99	}	127	}
100
101	}	128	}

src/PythonQtObjectPtr.h +13 -24

             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include <QVariant>
             #include <QVariantList>
             public:
               PythonQtObjectPtr():_object(NULL) {}
-              PythonQtObjectPtr(const PythonQtObjectPtr &p):_object(NULL) {
+              PythonQtObjectPtr(const PythonQtObjectPtr &p)
+              :_object(NULL) {
                 setObject(p.object());
               }
                   fromVariant(variant);
               }
-              PythonQtObjectPtr(PyObject* o) {
+              PythonQtObjectPtr(PyObject* o);
-                _object = o;
-                if (o) Py_INCREF(_object);
+              ~PythonQtObjectPtr();
-              ~PythonQtObjectPtr() { if (_object) { Py_DECREF(_object); } }
               //! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.
               bool fromVariant(const QVariant& variant);
               operator PyObject*() const { return object(); }
               //! sets the object and passes the ownership (stealing the reference, in Python slang)
-              void setNewRef(PyObject* o) {
+              void setNewRef(PyObject* o);
-                if (o != _object) {
-                  if (_object) { Py_DECREF(_object); }
-                  _object = o;
               PyObject* object() const {
                 return _object;
               }
             protected:
-              void setObject(PyObject* o) {
+              void setObject(PyObject* o);
-                if (o != _object) {
-                  if (_object) { Py_DECREF(_object); }
-                  _object = o;
-                  if (_object) { Py_INCREF(_object); }
             private:
               PyObject* _object;
             };
             Q_DECLARE_METATYPE(PythonQtObjectPtr)
             #endif

src/PythonQtSignalReceiver.h +2 -1

             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include "PythonQtObjectPtr.h"

src/PythonQtSlot.cpp +6 -6

             PythonQtSlotFunction_GetSlotInfo(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
-                PyErr_BadInternalCall();
+                PyErr_Format(PyExc_SystemError, "%s:%d: bad argument to internal function", __FILE__, __LINE__);
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_ml;
             PythonQtSlotFunction_GetSelf(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
-                PyErr_BadInternalCall();
+                PyErr_Format(PyExc_SystemError, "%s:%d: bad argument to internal function", __FILE__, __LINE__);
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_self;
             }
             static PyGetSetDef meth_getsets [] = {
-              {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
+              {const_cast<char*>("__doc__"),  (getter)meth_get__doc__,  NULL, NULL},
-              {"__name__", (getter)meth_get__name__, NULL, NULL},
+              {const_cast<char*>("__name__"), (getter)meth_get__name__, NULL, NULL},
-              {"__self__", (getter)meth_get__self__, NULL, NULL},
+              {const_cast<char*>("__self__"), (getter)meth_get__self__, NULL, NULL},
               {NULL, NULL, NULL,NULL},
             };
             #define OFF(x) offsetof(PythonQtSlotFunctionObject, x)
             static PyMemberDef meth_members[] = {
-              {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
+              {const_cast<char*>("__module__"),    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
               {NULL}
             };

src/PythonQtSlot.h +2 -1

             */
             //----------------------------------------------------------------------------------
-            #include "Python.h"
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include "structmember.h"

src/PythonQtStdDecorators.h +3 -1

             */
             //----------------------------------------------------------------------------------
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
-            #include <Python.h>
             #include <QObject>
             #include <QVariantList>
             #include <QTextDocument>

src/PythonQtStdOut.cpp +2 -2

             };
             static PyMemberDef PythonQtStdOutRedirect_members[] = {
-              {"softspace", T_INT, offsetof(PythonQtStdOutRedirect, softspace), 0,
+              {const_cast<char*>("softspace"), T_INT, offsetof(PythonQtStdOutRedirect, softspace), 0,
-                "soft space flag"
+                const_cast<char*>("soft space flag")
               },
               {NULL}  /* Sentinel */
             };

src/PythonQtStdOut.h +2 -1

             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "structmember.h"
             #include <QString>

src/gui/PythonQtScriptingConsole.h +2 -1

@@ -146,4 +146,5 private:
146		146
147		147
148		148
149	#endif No newline at end of file	149	#endif
		150

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages