Create a global namespace wrapper for each package if required

This currently just contains global enums. The content of these wrappers
will be added to the current package, and to the "Qt" package.

Also look in global namespace wrappers for scope-less enum types

Author: usiems

generator/abstractmetabuilder.cpp

@@ -391,6 +391,28 @@ void AbstractMetaBuilder::sortLists()
    }
 }
 
+AbstractMetaClass* AbstractMetaBuilder::getGlobalNamespace(const TypeEntry* typeEntry)
+{
+  QString package = typeEntry->javaPackage();
+  QString globalName = TypeDatabase::globalNamespaceClassName(typeEntry);
+
+  AbstractMetaClass* global = m_meta_classes.findClass(package + "." + globalName);
+  if (!global) {
+    ComplexTypeEntry* gte = new NamespaceTypeEntry(globalName);
+    gte->setTargetLangPackage(typeEntry->javaPackage());
+    gte->setCodeGeneration(typeEntry->codeGeneration());
+    global = createMetaClass();
+    global->setIsGlobalNamespace(true);
+    global->setTypeEntry(gte);
+    *global += AbstractMetaAttributes::Final;
+    *global += AbstractMetaAttributes::Public;
+    *global += AbstractMetaAttributes::Fake;
+
+    m_meta_classes << global;
+  }
+  return global;
+}
+
 bool AbstractMetaBuilder::build()
 {
     Q_ASSERT(!m_file_name.isEmpty());
@@ -460,36 +482,21 @@ bool AbstractMetaBuilder::build()
         AbstractMetaEnum *meta_enum = traverseEnum(item, 0, QSet<QString>());
 
         if (meta_enum) {
-            QString package = meta_enum->typeEntry()->javaPackage();
-            QString globalName = TypeDatabase::globalNamespaceClassName(meta_enum->typeEntry());
-
-            AbstractMetaClass *global = m_meta_classes.findClass(package + "." + globalName);
-            if (!global) {
-                ComplexTypeEntry *gte = new ObjectTypeEntry(globalName);
-                gte->setTargetLangPackage(meta_enum->typeEntry()->javaPackage());
-                gte->setCodeGeneration(meta_enum->typeEntry()->codeGeneration());
-                global = createMetaClass();
-                global->setTypeEntry(gte);
-                *global += AbstractMetaAttributes::Final;
-                *global += AbstractMetaAttributes::Public;
-                *global += AbstractMetaAttributes::Fake;
-
-                m_meta_classes << global;
-            }
+            AbstractMetaClass* global = getGlobalNamespace(meta_enum->typeEntry());
 
             global->addEnum(meta_enum);
-            meta_enum->setEnclosingClass(global);
-            meta_enum->typeEntry()->setQualifier(globalName);
 
             // Global enums should be public despite not having public
             // identifiers so we'll fix the original attributes here.
             meta_enum->setOriginalAttributes(meta_enum->attributes());
-        }
-
 
+            // global enums have their own include
+            if (meta_enum->typeEntry()->include().isValid()) {
+              global->typeEntry()->addExtraInclude(meta_enum->typeEntry()->include());
+            }
+        }
     }
 
-
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
     TypeAliasList typeAliases = m_dom->typeAliases();

generator/abstractmetabuilder.h

@@ -149,6 +149,8 @@ class AbstractMetaBuilder
 private:
     void sortLists();
 
+    AbstractMetaClass* getGlobalNamespace(const TypeEntry* typeEntry);
+
     QString m_file_name;
 
     AbstractMetaClassList m_meta_classes;

generator/abstractmetalang.h

@@ -676,6 +676,7 @@ class AbstractMetaClass : public AbstractMetaAttributes
           m_has_clone_operator(false),
           m_is_type_alias(false),
           m_has_actual_declaration(false),
+          m_is_global_namespace(false),
           m_qDebug_stream_function(0)
     {
     }
@@ -801,6 +802,9 @@ class AbstractMetaClass : public AbstractMetaAttributes
     void setHasActualDeclaration(bool on) { m_has_actual_declaration = on; }
     bool hasActualDeclaration() const { return m_has_actual_declaration; }
 
+    void setIsGlobalNamespace(bool on) { m_is_global_namespace = on; }
+    bool isGlobalNamespace() const { return m_is_global_namespace; }
+
     QString getDefaultNonZeroFunction() const;
 
     void addPropertySpec(QPropertySpec *spec) { m_property_specs << spec; }
@@ -862,7 +866,8 @@ class AbstractMetaClass : public AbstractMetaAttributes
     uint m_has_clone_operator :1;
     uint m_is_type_alias : 1;
     uint m_has_actual_declaration : 1;
-    uint m_reserved : 17;
+    uint m_is_global_namespace : 1;
+    uint m_reserved : 16;
     QString m_destructor_exception;
 
     const AbstractMetaClass *m_enclosing_class{};

generator/setupgenerator.cpp

@@ -337,6 +337,8 @@ void SetupGenerator::generate()
         }
         if (cls->isQObject()) {
           s << "PythonQt::priv()->registerClass(&" << cls->qualifiedCppName() << "::staticMetaObject, \"" << qtPackageName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
+        } else if (cls->isGlobalNamespace()) {
+          s << "PythonQt::priv()->registerGlobalNamespace(\"" << cls->qualifiedCppName() << "\", \"" << qtPackageName << "\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">, PythonQtWrapper_" << cls->name() << "::staticMetaObject, module); " << endl;
         } else {
           QString baseName = cls->baseClass()?cls->baseClass()->qualifiedCppName():"";
           s << "PythonQt::priv()->registerCPPClass(\""<< cls->qualifiedCppName() << "\", \"" << baseName << "\", \"" << qtPackageName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;

generator/shellgenerator.cpp

@@ -50,8 +50,6 @@
 bool ShellGenerator::shouldGenerate(const AbstractMetaClass *meta_class) const
 {
     uint cg = meta_class->typeEntry()->codeGeneration();
-    // ignore the "Global" namespace, which contains the QtMsgType enum
-    if (meta_class->name().startsWith("Global")) return false;
     return ((cg & TypeEntry::GenerateCode) != 0);
 }
 

generator/shellheadergenerator.cpp

@@ -312,7 +312,8 @@ void ShellHeaderGenerator::write(QTextStream& s, const AbstractMetaClass* meta_c
       bool isEnumClass = enum1->typeEntry()->isEnumClass();
       s << "enum " << (isEnumClass ? "class " : "") << enum1->name() << "{" << endl;
       bool first = true;
-      QString scope = enum1->wasProtected() ? promoterClassName(meta_class) : meta_class->qualifiedCppName();
+      QString scope = meta_class->isGlobalNamespace() ? QString() :
+          (enum1->wasProtected() ? promoterClassName(meta_class) : meta_class->qualifiedCppName());
       if (isEnumClass) {
         scope += "::" + enum1->name();
       }

generator/typesystem.cpp

@@ -1835,8 +1835,9 @@ FlagsTypeEntry *TypeDatabase::findFlagsType(const QString &name) const
     return fte ? fte : (FlagsTypeEntry *) m_flags_entries.value(name);
 }
 
-QString TypeDatabase::globalNamespaceClassName(const TypeEntry * /*entry*/) {
-    return QLatin1String("Global");
+QString TypeDatabase::globalNamespaceClassName(const TypeEntry * entry)
+{
+    return "Qt" + entry->javaPackage().split('.').back();
 }
 
 

src/PythonQt.cpp

@@ -2060,6 +2060,73 @@ void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentT
   }
 }
 
+namespace {
+
+  void addObjectToPackage(PyObject* obj, const char* name, const char* packageName, PyObject* package)
+  {
+    if (PyModule_AddObject(package, name, obj) < 0) {
+      Py_DECREF(obj);
+      std::cerr << "failed to add " << name << " to " << packageName << "\n";
+    }
+  }
+
+};
+
+void PythonQtPrivate::registerGlobalNamespace(const char* typeName, const char* packageName, PythonQtQObjectCreatorFunctionCB* wrapperCreator, const QMetaObject& metaObject, PyObject* module)
+{
+  registerCPPClass(typeName, "", packageName, wrapperCreator, nullptr, module, 0);
+
+  PyObject* package = module ? module : PythonQt::priv()->packageByName(packageName);
+  PythonQtClassInfo* classInfo = PythonQt::priv()->getClassInfo(typeName);
+  PyObject* globalNamespace = classInfo->pythonQtClassWrapper();
+
+  // Collect the names of global methods
+  QSet<QByteArray> methodNames;
+  for (int i = metaObject.methodOffset(); i < metaObject.methodCount(); i++) {
+    methodNames.insert(metaObject.method(i).name());
+  }
+  QByteArray staticPrefix = "static_" + QByteArray(typeName) + "_"; // every static method starts with this string
+  for (auto name: methodNames) {
+    if (name.startsWith(staticPrefix)) {  // non-static methods wouldn't work (and should not exists)
+      name = name.mid(staticPrefix.length());
+      PyObject* obj = PyObject_GetAttrString(globalNamespace, name.constData());
+      if (obj) {
+        addObjectToPackage(obj, name, packageName, package);
+      }
+      else {
+        std::cerr << "method not found " << name.constData() << " in " << typeName << std::endl;
+      }
+    }
+  }
+
+  // Global enums
+  for (int i = metaObject.enumeratorOffset(); i < metaObject.enumeratorCount(); i++) {
+    QMetaEnum metaEnum = metaObject.enumerator(i);
+    PyObject* obj = PyObject_GetAttrString(globalNamespace, metaEnum.name());
+    if (obj) {
+      addObjectToPackage(obj, metaEnum.name(), packageName, package);
+    }
+    else {
+      std::cerr << "enum type not found " << metaEnum.name() << " in " << typeName << std::endl;
+    }
+#if QT_VERSION > 0x050800
+    bool isScoped = metaEnum.isScoped();
+#else
+    bool isScoped = false;
+#endif
+    if (!isScoped) {
+      for (int j = 0; j < metaEnum.keyCount(); j++) {
+        QByteArray key = PythonQtClassInfo::escapeReservedNames(metaEnum.key(j));
+        int value = metaEnum.value(j);
+        PyObject* obj = PyInt_FromLong(value);
+        addObjectToPackage(obj, key, packageName, package);
+      }
+    }
+  }
+
+  PythonQtClassInfo::addGlobalNamespaceWrapper(classInfo);
+}
+
 PyObject* PythonQtPrivate::packageByName(const char* name)
 {
   if (name==nullptr || name[0]==0) {

src/PythonQt.h

@@ -742,6 +742,9 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
    */
   void registerCPPClass(const char* typeName, const char* parentTypeName = nullptr, const char* package = nullptr, PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr, PyObject* module = nullptr, int typeSlots = 0);
 
+  //! Same as above, but all enums of the created wrapper will also be added to the given package and to the "Qt" package
+  void registerGlobalNamespace(const char* typeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, const QMetaObject& metaObject, PyObject* module = nullptr);
+
   //! 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 registerQObjectClassNames(const QStringList& names);

src/PythonQtClassInfo.cpp

@@ -49,6 +49,9 @@
 
 QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;
 
+// List of registered global namespace wrappers that might contain a top-level enum definition
+QList<PythonQtClassInfo*> PythonQtClassInfo::_globalNamespaceWrappers;
+
 // List of words that are reserved in Python, but not in C++, so they need escaping
 QSet<QByteArray> PythonQtClassInfo::_reservedNames{
   "None", "True", "False"
@@ -851,11 +854,20 @@ PyObject* PythonQtClassInfo::findEnumWrapper(const QByteArray& name, PythonQtCla
       return nullptr;
     }
   }
+  PyObject* enumWrapper = nullptr;
   if (localScope) {
-    return localScope->findEnumWrapper(name);
-  } else {
-    return nullptr;
+    enumWrapper = localScope->findEnumWrapper(name);
+  } 
+  if (!enumWrapper) {
+    // it might be a top-level enum - search in all currently registered global namespace wrappers
+    for (PythonQtClassInfo* globalWrapper : _globalNamespaceWrappers) {
+      enumWrapper = globalWrapper->findEnumWrapper(name);
+      if (enumWrapper) {
+        break;
+      }
+    }
   }
+  return enumWrapper;
 }
 
 // required for the code below (for versions before Qt 6)
@@ -1033,6 +1045,11 @@ QByteArray PythonQtClassInfo::escapeReservedNames(const QByteArray& name)
   }
 }
 
+void PythonQtClassInfo::addGlobalNamespaceWrapper(PythonQtClassInfo* namespaceWrapper)
+{
+  _globalNamespaceWrappers.insert(0, namespaceWrapper);
+}
+
 void PythonQtClassInfo::updateRefCountingCBs()
 {
   if (!_refCallback) {