GIT_REPOSITORIES/LPP/PythonQt Commit - r109:7064022fb8cf

added support for passing a parent python module when registering a class and allow to change the name of the PythonQt module...

florianlink -

r109:7064022fb8cf

parent child

Context file:

r109:7064022fb8cf

Collapse all files

src/PythonQt.cpp +28 -27

             PythonQt* PythonQt::_self = NULL;
             int       PythonQt::_uniqueModuleCount = 0;
-            void PythonQt_init_QtGuiBuiltin();
+            void PythonQt_init_QtGuiBuiltin(PyObject*);
-            void PythonQt_init_QtCoreBuiltin();
+            void PythonQt_init_QtCoreBuiltin(PyObject*);
-            void PythonQt::init(int flags)
+            void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
             {
               if (!_self) {
-                _self = new PythonQt(flags);
+                _self = new PythonQt(flags, pythonQtModuleName);
                 PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");
                 qRegisterMetaType<QList<QObject*> >("QList<void*>");
                 PythonQt::self()->addDecorators(new PythonQtStdDecorators());
-              PythonQt_init_QtCoreBuiltin();
+                PythonQt_init_QtCoreBuiltin(NULL);
-              PythonQt_init_QtGuiBuiltin();
+                PythonQt_init_QtGuiBuiltin(NULL);
                 PythonQtRegisterToolClassesTemplateConverter(QDate);
                 PythonQtRegisterToolClassesTemplateConverter(QTime);
                   }
                 }
               }
+            }
             void PythonQt::cleanup()
             {
               }
             }
-            PythonQt::PythonQt(int flags)
+            PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)
             {
               _p = new PythonQtPrivate;
               _p->_initFlags = flags;
               }
               Py_INCREF(&PythonQtStdOutRedirectType);
-              initPythonQtModule(flags & RedirectStdOut);
+              initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);
               _p->setupSharedLibrarySuffixes();
               _p->registerClass(metaobject, package, wrapperCreator, shell);
             }
-            void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)
+            void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module)
             {
               // we register all classes in the hierarchy
               const QMetaObject* m = metaobject;
                 PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(m->className());
                 if (!info->pythonQtClassWrapper()) {
                   info->setupQObject(m);
-                  createPythonQtClassWrapper(info, package);
+                  createPythonQtClassWrapper(info, package, module);
                   if (m->superClass()) {
                     PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(m->superClass()->className());
                     info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo));
               }
             }
-            void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package)
+            void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module)
             {
-              PyObject* pack = packageByName(package);
+              PyObject* pack = module?module:packageByName(package);
-              PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, package);
+              PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, pack);
               PyModule_AddObject(pack, info->className(), pyobj);
-              if (package && strncmp(package,"Qt",2)==0) {
+              if (!module && package && strncmp(package,"Qt",2)==0) {
                 // since PyModule_AddObject steals the reference, we need a incref once more...
                 Py_INCREF(pyobj);
                 // put all qt objects into Qt as well
               return result;
             }
-            PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, const char* package) {
+            PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* parentModule) {
               PythonQtClassWrapper* result;
               PyObject* className = PyString_FromString(info->className());
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PythonQtInstanceWrapper_Type);
               PyObject* typeDict = PyDict_New();
-              QByteArray moduleName("PythonQt");
+              PyObject* moduleName = PyObject_GetAttrString(parentModule, "__name__");
-              if (package && strcmp(package, "")!=0) {
+              PyDict_SetItemString(typeDict, "__module__", moduleName);
-                moduleName += ".";
-                moduleName += package;
-              PyDict_SetItemString(typeDict, "__module__", PyString_FromString(moduleName.constData()));
               PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
               {NULL, NULL, 0, NULL}
             };
-            void PythonQt::initPythonQtModule(bool redirectStdOut)
+            void PythonQt::initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName)
             {
-              _p->_pythonQtModule = Py_InitModule("PythonQt", PythonQtMethods);
+              QByteArray name = "PythonQt";
+              if (!pythonQtModuleName.isEmpty()) {
+                name = pythonQtModuleName;
+              }
+              _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
+              _p->_pythonQtModuleName = name;
               if (redirectStdOut) {
                 PythonQtObjectPtr sys;
               }
             }
-            void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell)
+            void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell, PyObject* module)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               if (!info->pythonQtClassWrapper()) {
                 info->setupCPPObject(typeName);
-                createPythonQtClassWrapper(info, package);
+                createPythonQtClassWrapper(info, package, module);
               }
               if (parentTypeName && strcmp(parentTypeName,"")!=0) {
                 addParentClass(typeName, parentTypeName, 0);
               }
               PyObject* v = _packages.value(name);
               if (!v) {
-                v = PyImport_AddModule((QByteArray("PythonQt.") + name).constData());
+                v = PyImport_AddModule((_pythonQtModuleName + "." + name).constData());
                 _packages.insert(name, v);
                 // AddObject steals the reference, so increment it!
                 Py_INCREF(v);

src/PythonQt.h +13 -8

                 ExternalHelp = 4      //!<< sets if help() calls on PythonQt modules are forwarded to the pythonHelpRequest() signal
               };
-              //! initialize the python qt binding (flags are a or combination of InitFlags)
+              //! initialize the python qt binding (flags are a or combination of InitFlags), if \c pythonQtModuleName is given
-              static void init(int flags = IgnoreSiteModule | RedirectStdOut);
+              //! it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used.
+              //! This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.
+              static void init(int flags = IgnoreSiteModule | RedirectStdOut, const QByteArray& pythonQtModuleName = QByteArray());
               //! cleanup
               static void cleanup();
               PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);
             private:
-              void initPythonQtModule(bool redirectStdOut);
+              void initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName);
               //! callback for stdout redirection, emits pythonStdOut signal
               static void stdOutRedirectCB(const QString& str);
               //! get (and create if not available) the signal receiver of that QObject, signal receiver is made child of the passed \c obj
               PythonQtSignalReceiver* getSignalReceiver(QObject* obj);
-              PythonQt(int flags);
+              PythonQt(int flags, const QByteArray& pythonQtModuleName);
               ~PythonQt();
               static PythonQt* _self;
               //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
               /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
                  you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
-              void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
+              void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL);
               //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
               //! (ownership of wrapper is passed to PythonQt)
                All slots that take a pointer to typeName as the first argument will be callable from Python on
                a variant object that contains such a type.
                */
-              void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
+              void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL);
               //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
               //! and it will register the classes when it first sees a pointer to such a derived class
               void addDecorators(QObject* o, int decoTypes);
               //! helper method that creates a PythonQtClassWrapper object  (returns a new reference)
-              PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, const char* package = NULL);
+              PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* module);
               //! create a new instance of the given enum type with given value (returns a new reference)
               static PyObject*  createEnumValueInstance(PyObject* enumType, unsigned int enumValue);
               void setupSharedLibrarySuffixes();
               //! create a new pythonqt class wrapper and place it in the pythonqt module
-              void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package);
+              void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = NULL);
               //! get/create new package module (the returned object is a borrowed reference)
               PyObject* packageByName(const char* name);
               //! the PythonQt python module
               PythonQtObjectPtr _pythonQtModule;
+              //! the name of the PythonQt python module
+              QByteArray _pythonQtModuleName;
               //! the importer interface (if set)
               PythonQtImportFileInterface* _importInterface;

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