You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
197 lines
8.0 KiB
197 lines
8.0 KiB
# Code that packs and unpacks the Univgw structures.
|
|
|
|
# See if we have a special directory for the binaries (for developers)
|
|
import types
|
|
import pythoncom
|
|
from win32com.client import gencache
|
|
|
|
com_error = pythoncom.com_error
|
|
_univgw = pythoncom._univgw
|
|
|
|
def RegisterInterfaces(typelibGUID, lcid, major, minor, interface_names = None):
|
|
ret = [] # return a list of (dispid, funcname for our policy's benefit
|
|
# First see if we have makepy support. If so, we can probably satisfy the request without loading the typelib.
|
|
try:
|
|
mod = gencache.GetModuleForTypelib(typelibGUID, lcid, major, minor)
|
|
except ImportError:
|
|
mod = None
|
|
if mod is None:
|
|
import win32com.client.build
|
|
# Load up the typelib and build (but don't cache) it now
|
|
tlb = pythoncom.LoadRegTypeLib(typelibGUID, major, minor, lcid)
|
|
typecomp_lib = tlb.GetTypeComp()
|
|
if interface_names is None:
|
|
interface_names = []
|
|
for i in range(tlb.GetTypeInfoCount()):
|
|
info = tlb.GetTypeInfo(i)
|
|
doc = tlb.GetDocumentation(i)
|
|
attr = info.GetTypeAttr()
|
|
if attr.typekind == pythoncom.TKIND_INTERFACE or \
|
|
(attr.typekind == pythoncom.TKIND_DISPATCH and attr.wTypeFlags & pythoncom.TYPEFLAG_FDUAL):
|
|
interface_names.append(doc[0])
|
|
for name in interface_names:
|
|
type_info, type_comp = typecomp_lib.BindType(name, )
|
|
# Not sure why we don't get an exception here - BindType's C
|
|
# impl looks correct..
|
|
if type_info is None:
|
|
raise ValueError("The interface '%s' can not be located" % (name,))
|
|
# If we got back a Dispatch interface, convert to the real interface.
|
|
attr = type_info.GetTypeAttr()
|
|
if attr.typekind == pythoncom.TKIND_DISPATCH:
|
|
refhtype = type_info.GetRefTypeOfImplType(-1)
|
|
type_info = type_info.GetRefTypeInfo(refhtype)
|
|
attr = type_info.GetTypeAttr()
|
|
item = win32com.client.build.VTableItem(type_info, attr, type_info.GetDocumentation(-1))
|
|
_doCreateVTable(item.clsid, item.python_name, item.bIsDispatch, item.vtableFuncs)
|
|
for info in item.vtableFuncs:
|
|
names, dispid, desc = info
|
|
invkind = desc[4]
|
|
ret.append((dispid, invkind, names[0]))
|
|
else:
|
|
# Cool - can used cached info.
|
|
if not interface_names:
|
|
interface_names = list(mod.VTablesToClassMap.values())
|
|
for name in interface_names:
|
|
try:
|
|
iid = mod.NamesToIIDMap[name]
|
|
except KeyError:
|
|
raise ValueError("Interface '%s' does not exist in this cached typelib" % (name,))
|
|
# print "Processing interface", name
|
|
sub_mod = gencache.GetModuleForCLSID(iid)
|
|
is_dispatch = getattr(sub_mod, name + "_vtables_dispatch_", None)
|
|
method_defs = getattr(sub_mod, name + "_vtables_", None)
|
|
if is_dispatch is None or method_defs is None:
|
|
raise ValueError("Interface '%s' is IDispatch only" % (name,))
|
|
|
|
# And create the univgw defn
|
|
_doCreateVTable(iid, name, is_dispatch, method_defs)
|
|
for info in method_defs:
|
|
names, dispid, desc = info
|
|
invkind = desc[4]
|
|
ret.append((dispid, invkind, names[0]))
|
|
return ret
|
|
|
|
def _doCreateVTable(iid, interface_name, is_dispatch, method_defs):
|
|
defn = Definition(iid, is_dispatch, method_defs)
|
|
vtbl = _univgw.CreateVTable(defn, is_dispatch)
|
|
_univgw.RegisterVTable(vtbl, iid, interface_name)
|
|
|
|
def _CalcTypeSize(typeTuple):
|
|
t = typeTuple[0]
|
|
if t & (pythoncom.VT_BYREF | pythoncom.VT_ARRAY):
|
|
# Its a pointer.
|
|
cb = _univgw.SizeOfVT(pythoncom.VT_PTR)[1]
|
|
elif t == pythoncom.VT_RECORD:
|
|
# Just because a type library uses records doesn't mean the user
|
|
# is trying to. We need to better place to warn about this, but it
|
|
# isn't here.
|
|
#try:
|
|
# import warnings
|
|
# warnings.warn("warning: records are known to not work for vtable interfaces")
|
|
#except ImportError:
|
|
# print "warning: records are known to not work for vtable interfaces"
|
|
cb = _univgw.SizeOfVT(pythoncom.VT_PTR)[1]
|
|
#cb = typeInfo.GetTypeAttr().cbSizeInstance
|
|
else:
|
|
cb = _univgw.SizeOfVT(t)[1]
|
|
return cb
|
|
|
|
class Arg:
|
|
def __init__(self, arg_info, name = None):
|
|
self.name = name
|
|
self.vt, self.inOut, self.default, self.clsid = arg_info
|
|
self.size = _CalcTypeSize(arg_info)
|
|
# Offset from the beginning of the arguments of the stack.
|
|
self.offset = 0
|
|
|
|
class Method:
|
|
def __init__(self, method_info, isEventSink=0):
|
|
all_names, dispid, desc = method_info
|
|
name = all_names[0]
|
|
names = all_names[1:]
|
|
invkind = desc[4]
|
|
arg_defs = desc[2]
|
|
ret_def = desc[8]
|
|
|
|
self.dispid = dispid
|
|
self.invkind = invkind
|
|
# We dont use this ATM.
|
|
# self.ret = Arg(ret_def)
|
|
if isEventSink and name[:2] != "On":
|
|
name = "On%s" % name
|
|
self.name = name
|
|
cbArgs = 0
|
|
self.args = []
|
|
for argDesc in arg_defs:
|
|
arg = Arg(argDesc)
|
|
arg.offset = cbArgs
|
|
cbArgs = cbArgs + arg.size
|
|
self.args.append(arg)
|
|
self.cbArgs = cbArgs
|
|
self._gw_in_args = self._GenerateInArgTuple()
|
|
self._gw_out_args = self._GenerateOutArgTuple()
|
|
|
|
def _GenerateInArgTuple(self):
|
|
# Given a method, generate the in argument tuple
|
|
l = []
|
|
for arg in self.args:
|
|
if arg.inOut & pythoncom.PARAMFLAG_FIN or \
|
|
arg.inOut == 0:
|
|
l.append((arg.vt, arg.offset, arg.size))
|
|
return tuple(l)
|
|
|
|
def _GenerateOutArgTuple(self):
|
|
# Given a method, generate the out argument tuple
|
|
l = []
|
|
for arg in self.args:
|
|
if arg.inOut & pythoncom.PARAMFLAG_FOUT or \
|
|
arg.inOut & pythoncom.PARAMFLAG_FRETVAL or \
|
|
arg.inOut == 0:
|
|
l.append((arg.vt, arg.offset, arg.size, arg.clsid))
|
|
return tuple(l)
|
|
|
|
class Definition:
|
|
def __init__(self, iid, is_dispatch, method_defs):
|
|
self._iid = iid
|
|
self._methods = []
|
|
self._is_dispatch = is_dispatch
|
|
for info in method_defs:
|
|
entry = Method(info)
|
|
self._methods.append(entry)
|
|
def iid(self):
|
|
return self._iid
|
|
def vtbl_argsizes(self):
|
|
return [m.cbArgs for m in self._methods]
|
|
def vtbl_argcounts(self):
|
|
return [len(m.args) for m in self._methods]
|
|
def dispatch(self, ob, index, argPtr,
|
|
ReadFromInTuple=_univgw.ReadFromInTuple,
|
|
WriteFromOutTuple=_univgw.WriteFromOutTuple):
|
|
"Dispatch a call to an interface method."
|
|
meth = self._methods[index]
|
|
# Infer S_OK if they don't return anything bizarre.
|
|
hr = 0
|
|
args = ReadFromInTuple(meth._gw_in_args, argPtr)
|
|
# If ob is a dispatcher, ensure a policy
|
|
ob = getattr(ob, "policy", ob)
|
|
# Ensure the correct dispid is setup
|
|
ob._dispid_to_func_[meth.dispid] = meth.name
|
|
retVal = ob._InvokeEx_(meth.dispid, 0, meth.invkind, args, None, None)
|
|
# None is an allowed return value stating that
|
|
# the code doesn't want to touch any output arguments.
|
|
if type(retVal) == tuple: # Like pythoncom, we special case a tuple.
|
|
# However, if they want to return a specific HRESULT,
|
|
# then they have to return all of the out arguments
|
|
# AND the HRESULT.
|
|
if len(retVal) == len(meth._gw_out_args) + 1:
|
|
hr = retVal[0]
|
|
retVal = retVal[1:]
|
|
else:
|
|
raise TypeError("Expected %s return values, got: %s" % (len(meth._gw_out_args) + 1, len(retVal)))
|
|
else:
|
|
retVal = [retVal]
|
|
retVal.extend([None] * (len(meth._gw_out_args)-1))
|
|
retVal = tuple(retVal)
|
|
WriteFromOutTuple(retVal, meth._gw_out_args, argPtr)
|
|
return hr
|