Uploaded Test files

venv/Lib/site-packages/win32com/client/combrowse.py

@@ -0,0 +1,540 @@
+"""A utility for browsing COM objects.
+
+ Usage:
+
+  Command Prompt
+
+    Use the command *"python.exe catbrowse.py"*.  This will display
+    display a fairly small, modal dialog.
+
+  Pythonwin
+
+    Use the "Run Script" menu item, and this will create the browser in an
+    MDI window.  This window can be fully resized.
+
+ Details
+
+   This module allows browsing of registered Type Libraries, COM categories,
+   and running COM objects.  The display is similar to the Pythonwin object
+   browser, and displays the objects in a hierarchical window.
+
+   Note that this module requires the win32ui (ie, Pythonwin) distribution to
+   work.
+
+"""
+import win32con
+import win32api, win32ui
+import sys
+import pythoncom
+from win32com.client import util
+from pywin.tools import browser
+
+class HLIRoot(browser.HLIPythonObject):
+    def __init__(self, title):
+        self.name = title
+    def GetSubList(self):
+        return [HLIHeadingCategory(), HLI_IEnumMoniker(pythoncom.GetRunningObjectTable().EnumRunning(), "Running Objects"), HLIHeadingRegisterdTypeLibs()]
+    def __cmp__(self, other):
+        return cmp(self.name, other.name)
+
+class HLICOM(browser.HLIPythonObject):
+    def GetText(self):
+        return self.name
+    def CalculateIsExpandable(self):
+        return 1
+
+class HLICLSID(HLICOM):
+    def __init__(self, myobject, name=None ):
+        if type(myobject)==type(''):
+            myobject = pythoncom.MakeIID(myobject)
+        if name is None:
+            try:
+                name = pythoncom.ProgIDFromCLSID(myobject)
+            except pythoncom.com_error:
+                name = str(myobject)
+            name = "IID: " + name
+        HLICOM.__init__(self, myobject, name)
+    def CalculateIsExpandable(self):
+        return 0
+    def GetSubList(self):
+        return []
+
+class HLI_Interface(HLICOM):
+    pass
+
+class HLI_Enum(HLI_Interface):
+    def GetBitmapColumn(self):
+        return 0 # Always a folder.
+    def CalculateIsExpandable(self):
+        if self.myobject is not None:
+            rc = len(self.myobject.Next(1))>0
+            self.myobject.Reset()
+        else:
+            rc = 0
+        return rc
+    pass
+
+class HLI_IEnumMoniker(HLI_Enum):
+    def GetSubList(self):
+        ctx = pythoncom.CreateBindCtx()
+        ret = []
+        for mon in util.Enumerator(self.myobject):
+            ret.append(HLI_IMoniker(mon, mon.GetDisplayName(ctx, None)))
+        return ret
+
+class HLI_IMoniker(HLI_Interface):
+    def GetSubList(self):
+        ret = []
+        ret.append(browser.MakeHLI(self.myobject.Hash(), "Hash Value"))
+        subenum = self.myobject.Enum(1)
+        ret.append(HLI_IEnumMoniker(subenum, "Sub Monikers"))
+        return ret
+
+class HLIHeadingCategory(HLICOM):
+    "A tree heading for registered categories"
+    def GetText(self):
+        return "Registered Categories"
+    def GetSubList(self):
+        catinf=pythoncom.CoCreateInstance(pythoncom.CLSID_StdComponentCategoriesMgr,None,pythoncom.CLSCTX_INPROC,pythoncom.IID_ICatInformation)
+        enum=util.Enumerator(catinf.EnumCategories())
+        ret = []
+        try:
+            for catid, lcid, desc in enum:
+                ret.append(HLICategory((catid, lcid, desc)))
+        except pythoncom.com_error:
+            # Registered categories occasionally seem to give spurious errors.
+            pass # Use what we already have.
+        return ret
+
+class HLICategory(HLICOM):
+    "An actual Registered Category"
+    def GetText(self):
+        desc =  self.myobject[2]
+        if not desc: desc = "(unnamed category)"
+        return desc
+    def GetSubList(self):
+        win32ui.DoWaitCursor(1)
+        catid, lcid, desc = self.myobject
+        catinf=pythoncom.CoCreateInstance(pythoncom.CLSID_StdComponentCategoriesMgr,None,pythoncom.CLSCTX_INPROC,pythoncom.IID_ICatInformation)
+        ret = []
+        for clsid in util.Enumerator(catinf.EnumClassesOfCategories((catid,),())):
+            ret.append(HLICLSID(clsid))
+        win32ui.DoWaitCursor(0)
+
+        return ret
+
+class HLIHelpFile(HLICOM):
+    def CalculateIsExpandable(self):
+        return 0
+    def GetText(self):
+        import os
+        fname, ctx = self.myobject
+        base = os.path.split(fname)[1]
+        return "Help reference in %s" %( base)
+
+    def TakeDefaultAction(self):
+        fname, ctx = self.myobject
+        if ctx:
+            cmd = win32con.HELP_CONTEXT
+        else:
+            cmd = win32con.HELP_FINDER
+        win32api.WinHelp(win32ui.GetMainFrame().GetSafeHwnd(), fname, cmd, ctx)
+    def GetBitmapColumn(self):
+        return 6
+
+class HLIRegisteredTypeLibrary(HLICOM):
+    def GetSubList(self):
+        import os
+        clsidstr, versionStr = self.myobject
+        collected = []
+        helpPath = ""
+        key = win32api.RegOpenKey(win32con.HKEY_CLASSES_ROOT, "TypeLib\\%s\\%s" % (clsidstr, versionStr))
+        win32ui.DoWaitCursor(1)
+        try:
+            num = 0
+            while 1:
+                try:
+                    subKey = win32api.RegEnumKey(key, num)
+                except win32api.error:
+                    break
+                hSubKey = win32api.RegOpenKey(key, subKey)
+                try:
+                    value, typ = win32api.RegQueryValueEx(hSubKey, None)
+                    if typ == win32con.REG_EXPAND_SZ:
+                        value = win32api.ExpandEnvironmentStrings(value)
+                except win32api.error:
+                    value = ""
+                if subKey=="HELPDIR":
+                    helpPath = value
+                elif subKey=="Flags":
+                    flags = value
+                else:
+                    try:
+                        lcid = int(subKey)
+                        lcidkey = win32api.RegOpenKey(key, subKey)
+                        # Enumerate the platforms
+                        lcidnum = 0
+                        while 1:
+                            try:
+                                platform = win32api.RegEnumKey(lcidkey, lcidnum)
+                            except win32api.error:
+                                break
+                            try:
+                                hplatform = win32api.RegOpenKey(lcidkey, platform)
+                                fname, typ = win32api.RegQueryValueEx(hplatform, None)
+                                if typ == win32con.REG_EXPAND_SZ:
+                                    fname = win32api.ExpandEnvironmentStrings(fname)
+                            except win32api.error:
+                                fname = ""
+                            collected.append((lcid, platform, fname))
+                            lcidnum = lcidnum + 1
+                        win32api.RegCloseKey(lcidkey)
+                    except ValueError:
+                        pass
+                num = num + 1
+        finally:
+            win32ui.DoWaitCursor(0)
+            win32api.RegCloseKey(key)
+        # Now, loop over my collected objects, adding a TypeLib and a HelpFile
+        ret = []
+#               if helpPath: ret.append(browser.MakeHLI(helpPath, "Help Path"))
+        ret.append(HLICLSID(clsidstr))
+        for lcid, platform, fname in collected:
+            extraDescs = []
+            if platform!="win32":
+                extraDescs.append(platform)
+            if lcid:
+                extraDescs.append("locale=%s"%lcid)
+            extraDesc = ""
+            if extraDescs: extraDesc = " (%s)" % ", ".join(extraDescs)
+            ret.append(HLITypeLib(fname, "Type Library" + extraDesc))
+        ret.sort()
+        return ret
+
+class HLITypeLibEntry(HLICOM):
+    def GetText(self):
+        tlb, index = self.myobject
+        name, doc, ctx, helpFile = tlb.GetDocumentation(index)
+        try:
+            typedesc = HLITypeKinds[tlb.GetTypeInfoType(index)][1]
+        except KeyError:
+            typedesc = "Unknown!"
+        return name + " - " + typedesc
+    def GetSubList(self):
+        tlb, index = self.myobject
+        name, doc, ctx, helpFile = tlb.GetDocumentation(index)
+        ret = []
+        if doc: ret.append(browser.HLIDocString(doc, "Doc"))
+        if helpFile: ret.append(HLIHelpFile(    (helpFile, ctx) ))
+        return ret
+
+class HLICoClass(HLITypeLibEntry):
+    def GetSubList(self):
+        ret = HLITypeLibEntry.GetSubList(self)
+        tlb, index = self.myobject
+        typeinfo = tlb.GetTypeInfo(index)
+        attr = typeinfo.GetTypeAttr()
+        for j in range(attr[8]):
+            flags = typeinfo.GetImplTypeFlags(j)
+            refType = typeinfo.GetRefTypeInfo(typeinfo.GetRefTypeOfImplType(j))
+            refAttr = refType.GetTypeAttr()
+            ret.append(browser.MakeHLI(refAttr[0], "Name=%s, Flags = %d" % (refAttr[0], flags)))
+        return ret
+
+
+class HLITypeLibMethod(HLITypeLibEntry):
+    def __init__(self, ob, name = None):
+        self.entry_type = "Method"
+        HLITypeLibEntry.__init__(self, ob, name)
+    def GetSubList(self):
+        ret = HLITypeLibEntry.GetSubList(self)
+        tlb, index = self.myobject
+        typeinfo = tlb.GetTypeInfo(index)
+        attr = typeinfo.GetTypeAttr()
+        for i in range(attr[7]):
+            ret.append(HLITypeLibProperty((typeinfo, i)))
+        for i in range(attr[6]):
+            ret.append(HLITypeLibFunction((typeinfo, i)))
+        return ret
+
+class HLITypeLibEnum(HLITypeLibEntry):
+    def __init__(self, myitem):
+        typelib, index = myitem
+        typeinfo = typelib.GetTypeInfo(index)
+        self.id = typeinfo.GetVarDesc(index)[0]
+        name = typeinfo.GetNames(self.id)[0]
+        HLITypeLibEntry.__init__(self, myitem, name)
+    def GetText(self):
+        return self.name + " - Enum/Module"
+    def GetSubList(self):
+        ret = []
+        typelib, index = self.myobject
+        typeinfo = typelib.GetTypeInfo(index)
+        attr = typeinfo.GetTypeAttr()
+        for j in range(attr[7]):
+            vdesc = typeinfo.GetVarDesc(j)
+            name = typeinfo.GetNames(vdesc[0])[0]
+            ret.append(browser.MakeHLI(vdesc[1], name))
+        return ret
+
+class HLITypeLibProperty(HLICOM):
+    def __init__(self, myitem):
+        typeinfo, index = myitem
+        self.id = typeinfo.GetVarDesc(index)[0]
+        name = typeinfo.GetNames(self.id)[0]
+        HLICOM.__init__(self, myitem, name)
+    def GetText(self):
+        return self.name + " - Property"
+    def GetSubList(self):
+        ret = []
+        typeinfo, index = self.myobject
+        names = typeinfo.GetNames(self.id)
+        if len(names)>1:
+            ret.append(browser.MakeHLI(names[1:], "Named Params"))
+        vd = typeinfo.GetVarDesc(index)
+        ret.append(browser.MakeHLI(self.id, "Dispatch ID"))
+        ret.append(browser.MakeHLI(vd[1], "Value"))
+        ret.append(browser.MakeHLI(vd[2], "Elem Desc"))
+        ret.append(browser.MakeHLI(vd[3], "Var Flags"))
+        ret.append(browser.MakeHLI(vd[4], "Var Kind"))
+        return ret
+
+class HLITypeLibFunction(HLICOM):
+    funckinds = {pythoncom.FUNC_VIRTUAL : "Virtual",
+                 pythoncom.FUNC_PUREVIRTUAL : "Pure Virtual",
+                 pythoncom.FUNC_STATIC : "Static",
+                 pythoncom.FUNC_DISPATCH : "Dispatch",
+            }
+    invokekinds = {pythoncom.INVOKE_FUNC: "Function",
+                 pythoncom.INVOKE_PROPERTYGET : "Property Get",
+                 pythoncom.INVOKE_PROPERTYPUT : "Property Put",
+                 pythoncom.INVOKE_PROPERTYPUTREF : "Property Put by reference",
+            }
+    funcflags = [(pythoncom.FUNCFLAG_FRESTRICTED, "Restricted"),
+               (pythoncom.FUNCFLAG_FSOURCE, "Source"),
+               (pythoncom.FUNCFLAG_FBINDABLE, "Bindable"),
+               (pythoncom.FUNCFLAG_FREQUESTEDIT, "Request Edit"),
+               (pythoncom.FUNCFLAG_FDISPLAYBIND, "Display Bind"),
+               (pythoncom.FUNCFLAG_FDEFAULTBIND, "Default Bind"),
+               (pythoncom.FUNCFLAG_FHIDDEN, "Hidden"),
+               (pythoncom.FUNCFLAG_FUSESGETLASTERROR, "Uses GetLastError"),
+               ]
+
+    vartypes = {pythoncom.VT_EMPTY: "Empty",
+            pythoncom.VT_NULL: "NULL",
+            pythoncom.VT_I2: "Integer 2",
+            pythoncom.VT_I4: "Integer 4",
+            pythoncom.VT_R4: "Real 4",
+            pythoncom.VT_R8: "Real 8",
+            pythoncom.VT_CY: "CY",
+            pythoncom.VT_DATE: "Date",
+            pythoncom.VT_BSTR: "String",
+            pythoncom.VT_DISPATCH: "IDispatch",
+            pythoncom.VT_ERROR: "Error",
+            pythoncom.VT_BOOL: "BOOL",
+            pythoncom.VT_VARIANT: "Variant",
+            pythoncom.VT_UNKNOWN: "IUnknown",
+            pythoncom.VT_DECIMAL: "Decimal",
+            pythoncom.VT_I1: "Integer 1",
+            pythoncom.VT_UI1: "Unsigned integer 1",
+            pythoncom.VT_UI2: "Unsigned integer 2",
+            pythoncom.VT_UI4: "Unsigned integer 4",
+            pythoncom.VT_I8: "Integer 8",
+            pythoncom.VT_UI8: "Unsigned integer 8",
+            pythoncom.VT_INT: "Integer",
+            pythoncom.VT_UINT: "Unsigned integer",
+            pythoncom.VT_VOID: "Void",
+            pythoncom.VT_HRESULT: "HRESULT",
+            pythoncom.VT_PTR: "Pointer",
+            pythoncom.VT_SAFEARRAY: "SafeArray",
+            pythoncom.VT_CARRAY: "C Array",
+            pythoncom.VT_USERDEFINED: "User Defined",
+            pythoncom.VT_LPSTR: "Pointer to string",
+            pythoncom.VT_LPWSTR: "Pointer to Wide String",
+            pythoncom.VT_FILETIME: "File time",
+            pythoncom.VT_BLOB: "Blob",
+            pythoncom.VT_STREAM: "IStream",
+            pythoncom.VT_STORAGE: "IStorage",
+            pythoncom.VT_STORED_OBJECT: "Stored object",
+            pythoncom.VT_STREAMED_OBJECT: "Streamed object",
+            pythoncom.VT_BLOB_OBJECT: "Blob object",
+            pythoncom.VT_CF: "CF",
+            pythoncom.VT_CLSID: "CLSID",
+    }
+
+    type_flags = [ (pythoncom.VT_VECTOR, "Vector"),
+               (pythoncom.VT_ARRAY, "Array"),
+               (pythoncom.VT_BYREF, "ByRef"),
+               (pythoncom.VT_RESERVED, "Reserved"),
+    ]
+
+    def __init__(self, myitem):
+        typeinfo, index = myitem
+        self.id = typeinfo.GetFuncDesc(index)[0]
+        name = typeinfo.GetNames(self.id)[0]
+        HLICOM.__init__(self, myitem, name)
+    def GetText(self):
+        return self.name + " - Function"
+    def MakeReturnTypeName(self, typ):
+        justtyp = typ & pythoncom.VT_TYPEMASK
+        try:
+            typname = self.vartypes[justtyp]
+        except KeyError:
+            typname = "?Bad type?"
+        for (flag, desc) in self.type_flags:
+            if flag & typ:
+                typname = "%s(%s)" % (desc, typname)
+        return typname
+    def MakeReturnType(self, returnTypeDesc):
+        if type(returnTypeDesc)==type(()):
+            first = returnTypeDesc[0]
+            result = self.MakeReturnType(first)
+            if first != pythoncom.VT_USERDEFINED:
+                result = result + " " + self.MakeReturnType(returnTypeDesc[1])
+            return result
+        else:
+            return self.MakeReturnTypeName(returnTypeDesc)
+
+    def GetSubList(self):
+        ret = []
+        typeinfo, index = self.myobject
+        names = typeinfo.GetNames(self.id)
+        ret.append(browser.MakeHLI(self.id, "Dispatch ID"))
+        if len(names)>1:
+            ret.append(browser.MakeHLI(", ".join(names[1:]), "Named Params"))
+        fd = typeinfo.GetFuncDesc(index)
+        if fd[1]:
+            ret.append(browser.MakeHLI(fd[1], "Possible result values"))
+        if fd[8]:
+            typ, flags, default = fd[8]
+            val = self.MakeReturnType(typ)
+            if flags:
+                val = "%s (Flags=%d, default=%s)" % (val, flags, default)
+            ret.append(browser.MakeHLI(val, "Return Type"))
+
+        for argDesc in fd[2]:
+            typ, flags, default = argDesc
+            val = self.MakeReturnType(typ)
+            if flags:
+                val = "%s (Flags=%d)" % (val, flags)
+            if default is not None:
+                val = "%s (Default=%s)" % (val, default)
+            ret.append(browser.MakeHLI(val, "Argument"))
+
+        try:
+            fkind = self.funckinds[fd[3]]
+        except KeyError:
+            fkind = "Unknown"
+        ret.append(browser.MakeHLI(fkind, "Function Kind"))
+        try:
+            ikind = self.invokekinds[fd[4]]
+        except KeyError:
+            ikind = "Unknown"
+        ret.append(browser.MakeHLI(ikind, "Invoke Kind"))
+        # 5 = call conv
+        # 5 = offset vtbl
+        ret.append(browser.MakeHLI(fd[6], "Number Optional Params"))
+        flagDescs = []
+        for flag, desc in self.funcflags:
+            if flag & fd[9]:
+                flagDescs.append(desc)
+        if flagDescs:
+            ret.append(browser.MakeHLI(", ".join(flagDescs), "Function Flags"))
+        return ret
+
+HLITypeKinds = {
+                pythoncom.TKIND_ENUM : (HLITypeLibEnum, 'Enumeration'),
+                pythoncom.TKIND_RECORD : (HLITypeLibEntry, 'Record'),
+                pythoncom.TKIND_MODULE : (HLITypeLibEnum, 'Module'),
+                pythoncom.TKIND_INTERFACE : (HLITypeLibMethod, 'Interface'),
+                pythoncom.TKIND_DISPATCH : (HLITypeLibMethod, 'Dispatch'),
+                pythoncom.TKIND_COCLASS : (HLICoClass, 'CoClass'),
+                pythoncom.TKIND_ALIAS : (HLITypeLibEntry, 'Alias'),
+                pythoncom.TKIND_UNION : (HLITypeLibEntry, 'Union')
+        }
+
+class HLITypeLib(HLICOM):
+    def GetSubList(self):
+        ret = []
+        ret.append(browser.MakeHLI(self.myobject, "Filename"))
+        try:
+            tlb = pythoncom.LoadTypeLib(self.myobject)
+        except pythoncom.com_error:
+            return [browser.MakeHLI("%s can not be loaded" % self.myobject)]
+
+        for i in range(tlb.GetTypeInfoCount()):
+            try:
+                ret.append(HLITypeKinds[tlb.GetTypeInfoType(i)][0]( (tlb, i) ) )
+            except pythoncom.com_error:
+                ret.append(browser.MakeHLI("The type info can not be loaded!"))
+        ret.sort()
+        return ret
+
+class HLIHeadingRegisterdTypeLibs(HLICOM):
+    "A tree heading for registered type libraries"
+    def GetText(self):
+        return "Registered Type Libraries"
+    def GetSubList(self):
+        # Explicit lookup in the registry.
+        ret = []
+        key = win32api.RegOpenKey(win32con.HKEY_CLASSES_ROOT, "TypeLib")
+        win32ui.DoWaitCursor(1)
+        try:
+            num = 0
+            while 1:
+                try:
+                    keyName = win32api.RegEnumKey(key, num)
+                except win32api.error:
+                    break
+                # Enumerate all version info
+                subKey = win32api.RegOpenKey(key, keyName)
+                name = None
+                try:
+                    subNum = 0
+                    bestVersion = 0.0
+                    while 1:
+                        try:
+                            versionStr = win32api.RegEnumKey(subKey, subNum)
+                        except win32api.error:
+                            break
+                        try:
+                            versionFlt = float(versionStr)
+                        except ValueError:
+                            versionFlt = 0 # ????
+                        if versionFlt > bestVersion:
+                            bestVersion = versionFlt
+                            name = win32api.RegQueryValue(subKey, versionStr)
+                        subNum = subNum + 1
+                finally:
+                    win32api.RegCloseKey(subKey)
+                if name is not None:
+                    ret.append(HLIRegisteredTypeLibrary((keyName, versionStr), name))
+                num = num + 1
+        finally:
+            win32api.RegCloseKey(key)
+            win32ui.DoWaitCursor(0)
+        ret.sort()
+        return ret
+
+def main():
+    from pywin.tools import hierlist
+    root = HLIRoot("COM Browser")
+    if "app" in sys.modules:
+        # do it in a window
+        browser.MakeTemplate()
+        browser.template.OpenObject(root)
+    else:
+#               list=hierlist.HierListWithItems( root, win32ui.IDB_BROWSER_HIER )
+#               dlg=hierlist.HierDialog("COM Browser",list)
+        dlg = browser.dynamic_browser(root)
+        dlg.DoModal()
+
+
+
+if __name__=='__main__':
+    main()
+
+    ni = pythoncom._GetInterfaceCount()
+    ng = pythoncom._GetGatewayCount()
+    if ni or ng:
+        print("Warning - exiting with %d/%d objects alive" % (ni,ng))