1 files changed, 50 insertions, 16 deletions
diff --git a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
index e6f6dc379..a5e3247b1 100644
--- a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
+++ b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/signature/lib/enum_sig.py
@@ -52,6 +52,11 @@ by producing a lot of clarity.
 import sys
 from shibokensupport.signature import inspect
 from shibokensupport.signature import get_signature
+try:
+    from PySide2.QtCore import Qt
+    EnumType = type(Qt.Key)
+except ImportError:
+    EnumType = None
 
 
 class ExactEnumerator(object):
@@ -66,6 +71,13 @@ class ExactEnumerator(object):
     def __init__(self, formatter, result_type=dict):
         self.fmt = formatter
         self.result_type = result_type
+        self.fmt.level = 0
+        self.fmt.after_enum = self.after_enum
+        self._after_enum = False
+
+    def after_enum(self):
+        ret = self._after_enum
+        self._after_enum = False
 
     def module(self, mod_name):
         __import__(mod_name)
@@ -75,21 +87,19 @@ class ExactEnumerator(object):
             functions = inspect.getmembers(module, inspect.isroutine)
             ret = self.result_type()
             self.fmt.class_name = None
-            for func_name, func in functions:
-                ret.update(self.function(func_name, func))
             for class_name, klass in members:
                 ret.update(self.klass(class_name, klass))
+            if isinstance(klass, EnumType):
+                self.enum(klass)
+            for func_name, func in functions:
+                ret.update(self.function(func_name, func))
             return ret
 
     def klass(self, class_name, klass):
-        if not "Shiboken" in repr(klass.mro()):
-            # don't look into any foreign classes!
-            ret = self.result_type()
-            return ret
         bases_list = []
         for base in klass.__bases__:
             name = base.__name__
-            if name == "object":
+            if name in ("object", "type"):
                 pass
             else:
                 modname = base.__module__
@@ -97,30 +107,54 @@ class ExactEnumerator(object):
             bases_list.append(name)
         class_str = "{}({})".format(class_name, ", ".join(bases_list))
         with self.fmt.klass(class_name, class_str):
-            ret = self.function("__init__", klass)
+            ret = self.result_type()
             # class_members = inspect.getmembers(klass)
             # gives us also the inherited things.
             class_members = sorted(list(klass.__dict__.items()))
             subclasses = []
+            functions = []
             for thing_name, thing in class_members:
                 if inspect.isclass(thing):
                     subclass_name = ".".join((class_name, thing_name))
                     subclasses.append((subclass_name, thing))
-                else:
+                elif inspect.isroutine(thing):
                     func_name = thing_name.split(".")[0]   # remove ".overload"
-                    ret.update(self.function(func_name, thing))
+                    functions.append((func_name, thing))
+            self.fmt.level += 1
             for subclass_name, subclass in subclasses:
                 ret.update(self.klass(subclass_name, subclass))
-            return ret
+                if isinstance(subclass, EnumType):
+                    self.enum(subclass)
+            ret = self.function("__init__", klass)
+            for func_name, func in functions:
+                func_kind = get_signature(func, "__func_kind__")
+                modifier = func_kind if func_kind in (
+                    "staticmethod", "classmethod") else None
+                ret.update(self.function(func_name, func, modifier))
+            self.fmt.level -= 1
+        return ret
 
-    def function(self, func_name, func):
+    def function(self, func_name, func, modifier=None):
+        self.fmt.level += 1
         ret = self.result_type()
         signature = getattr(func, '__signature__', None)
         if signature is not None:
-            with self.fmt.function(func_name, signature) as key:
+            with self.fmt.function(func_name, signature, modifier) as key:
                 ret[key] = signature
+        self.fmt.level -= 1
         return ret
 
+    def enum(self, subclass):
+        if not hasattr(self.fmt, "enum"):
+            # this is an optional feature
+            return
+        class_name = subclass.__name__
+        for enum_name, value in subclass.__dict__.items():
+            if type(type(value)) is EnumType:
+                with self.fmt.enum(class_name, enum_name, int(value)):
+                    pass
+        self._after_enum = True
+
 
 def stringify(signature):
     if isinstance(signature, list):
@@ -142,7 +176,7 @@ class SimplifyingEnumerator(ExactEnumerator):
     is desired.
     """
 
-    def function(self, func_name, func):
+    def function(self, func_name, func, modifier=None):
         ret = self.result_type()
         signature = get_signature(func, 'existence')
         sig = stringify(signature) if signature is not None else None
@@ -159,11 +193,11 @@ class HintingEnumerator(ExactEnumerator):
     hinting stubs. Only default values are replaced by "...".
     """
 
-    def function(self, func_name, func):
+    def function(self, func_name, func, modifier=None):
         ret = self.result_type()
         signature = get_signature(func, 'hintingstub')
         if signature is not None:
-            with self.fmt.function(func_name, signature) as key:
+            with self.fmt.function(func_name, signature, modifier) as key:
                 ret[key] = signature
         return ret