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_QtCoreBuiltin();
+             void PythonQt_init_QtGuiBuiltin(PyObject*);
+             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_QtGuiBuiltin();
+                 PythonQt_init_QtCoreBuiltin(NULL);
+                 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* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, package);
+               PyObject* pack = module?module:packageByName(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");
-               if (package && strcmp(package, "")!=0) {
-                 moduleName += ".";
-                 moduleName += package;
+               }
-               PyDict_SetItemString(typeDict, "__module__", PyString_FromString(moduleName.constData()));
+               PyObject* moduleName = PyObject_GetAttrString(parentModule, "__name__");
+               PyDict_SetItemString(typeDict, "__module__", moduleName);
                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)
-               static void init(int flags = IgnoreSiteModule | RedirectStdOut);
+               //! initialize the python qt binding (flags are a or combination of InitFlags), if \c pythonQtModuleName is given
+               //! 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