581 lines
22 KiB
Python
581 lines
22 KiB
Python
"""Support for dynamic COM client support.
|
|
|
|
Introduction
|
|
Dynamic COM client support is the ability to use a COM server without
|
|
prior knowledge of the server. This can be used to talk to almost all
|
|
COM servers, including much of MS Office.
|
|
|
|
In general, you should not use this module directly - see below.
|
|
|
|
Example
|
|
>>> import win32com.client
|
|
>>> xl = win32com.client.Dispatch("Excel.Application")
|
|
# The line above invokes the functionality of this class.
|
|
# xl is now an object we can use to talk to Excel.
|
|
>>> xl.Visible = 1 # The Excel window becomes visible.
|
|
|
|
"""
|
|
import sys
|
|
import traceback
|
|
import types
|
|
|
|
import pythoncom
|
|
import winerror
|
|
from . import build
|
|
|
|
from pywintypes import IIDType
|
|
|
|
import win32com.client # Needed as code we eval() references it.
|
|
|
|
debugging=0 # General debugging
|
|
debugging_attr=0 # Debugging dynamic attribute lookups.
|
|
|
|
LCID = 0x0
|
|
|
|
# These errors generally mean the property or method exists,
|
|
# but can't be used in this context - eg, property instead of a method, etc.
|
|
# Used to determine if we have a real error or not.
|
|
ERRORS_BAD_CONTEXT = [
|
|
winerror.DISP_E_MEMBERNOTFOUND,
|
|
winerror.DISP_E_BADPARAMCOUNT,
|
|
winerror.DISP_E_PARAMNOTOPTIONAL,
|
|
winerror.DISP_E_TYPEMISMATCH,
|
|
winerror.E_INVALIDARG,
|
|
]
|
|
|
|
ALL_INVOKE_TYPES = [
|
|
pythoncom.INVOKE_PROPERTYGET,
|
|
pythoncom.INVOKE_PROPERTYPUT,
|
|
pythoncom.INVOKE_PROPERTYPUTREF,
|
|
pythoncom.INVOKE_FUNC
|
|
]
|
|
|
|
def debug_print(*args):
|
|
if debugging:
|
|
for arg in args:
|
|
print(arg, end=' ')
|
|
print()
|
|
|
|
def debug_attr_print(*args):
|
|
if debugging_attr:
|
|
for arg in args:
|
|
print(arg, end=' ')
|
|
print()
|
|
|
|
# A helper to create method objects on the fly
|
|
py3k = sys.version_info > (3,0)
|
|
if py3k:
|
|
def MakeMethod(func, inst, cls):
|
|
return types.MethodType(func, inst) # class not needed in py3k
|
|
else:
|
|
MakeMethod = types.MethodType # all args used in py2k.
|
|
|
|
# get the type objects for IDispatch and IUnknown
|
|
PyIDispatchType = pythoncom.TypeIIDs[pythoncom.IID_IDispatch]
|
|
PyIUnknownType = pythoncom.TypeIIDs[pythoncom.IID_IUnknown]
|
|
|
|
if py3k:
|
|
_GoodDispatchTypes=(str, IIDType)
|
|
else:
|
|
_GoodDispatchTypes=(str, IIDType, str)
|
|
_defaultDispatchItem=build.DispatchItem
|
|
|
|
def _GetGoodDispatch(IDispatch, clsctx = pythoncom.CLSCTX_SERVER):
|
|
# quick return for most common case
|
|
if isinstance(IDispatch, PyIDispatchType):
|
|
return IDispatch
|
|
if isinstance(IDispatch, _GoodDispatchTypes):
|
|
try:
|
|
IDispatch = pythoncom.connect(IDispatch)
|
|
except pythoncom.ole_error:
|
|
IDispatch = pythoncom.CoCreateInstance(IDispatch, None, clsctx, pythoncom.IID_IDispatch)
|
|
else:
|
|
# may already be a wrapped class.
|
|
IDispatch = getattr(IDispatch, "_oleobj_", IDispatch)
|
|
return IDispatch
|
|
|
|
def _GetGoodDispatchAndUserName(IDispatch, userName, clsctx):
|
|
# Get a dispatch object, and a 'user name' (ie, the name as
|
|
# displayed to the user in repr() etc.
|
|
if userName is None:
|
|
# Displayed name should be a plain string in py2k, and unicode in py3k
|
|
if isinstance(IDispatch, str):
|
|
userName = IDispatch
|
|
elif not py3k and isinstance(IDispatch, str):
|
|
# 2to3 converts the above 'unicode' to 'str', but this will never be executed in py3k
|
|
userName = IDispatch.encode("ascii", "replace")
|
|
## ??? else userName remains None ???
|
|
elif not py3k and isinstance(userName, str):
|
|
# 2to3 converts the above 'unicode' to 'str', but this will never be executed in py3k
|
|
# As above - always a plain string in py2k
|
|
userName = userName.encode("ascii", "replace")
|
|
else:
|
|
userName = str(userName)
|
|
return (_GetGoodDispatch(IDispatch, clsctx), userName)
|
|
|
|
def _GetDescInvokeType(entry, invoke_type):
|
|
# determine the wFlags argument passed as input to IDispatch::Invoke
|
|
if not entry or not entry.desc: return invoke_type
|
|
varkind = entry.desc[4] # from VARDESC struct returned by ITypeComp::Bind
|
|
if varkind == pythoncom.VAR_DISPATCH and invoke_type == pythoncom.INVOKE_PROPERTYGET:
|
|
return pythoncom.INVOKE_FUNC | invoke_type # DISPATCH_METHOD & DISPATCH_PROPERTYGET can be combined in IDispatch::Invoke
|
|
else:
|
|
return varkind
|
|
|
|
def Dispatch(IDispatch, userName = None, createClass = None, typeinfo = None, UnicodeToString=None, clsctx = pythoncom.CLSCTX_SERVER):
|
|
assert UnicodeToString is None, "this is deprecated and will go away"
|
|
IDispatch, userName = _GetGoodDispatchAndUserName(IDispatch,userName,clsctx)
|
|
if createClass is None:
|
|
createClass = CDispatch
|
|
lazydata = None
|
|
try:
|
|
if typeinfo is None:
|
|
typeinfo = IDispatch.GetTypeInfo()
|
|
if typeinfo is not None:
|
|
try:
|
|
#try for a typecomp
|
|
typecomp = typeinfo.GetTypeComp()
|
|
lazydata = typeinfo, typecomp
|
|
except pythoncom.com_error:
|
|
pass
|
|
except pythoncom.com_error:
|
|
typeinfo = None
|
|
olerepr = MakeOleRepr(IDispatch, typeinfo, lazydata)
|
|
return createClass(IDispatch, olerepr, userName, lazydata=lazydata)
|
|
|
|
def MakeOleRepr(IDispatch, typeinfo, typecomp):
|
|
olerepr = None
|
|
if typeinfo is not None:
|
|
try:
|
|
attr = typeinfo.GetTypeAttr()
|
|
# If the type info is a special DUAL interface, magically turn it into
|
|
# a DISPATCH typeinfo.
|
|
if attr[5] == pythoncom.TKIND_INTERFACE and attr[11] & pythoncom.TYPEFLAG_FDUAL:
|
|
# Get corresponding Disp interface;
|
|
# -1 is a special value which does this for us.
|
|
href = typeinfo.GetRefTypeOfImplType(-1);
|
|
typeinfo = typeinfo.GetRefTypeInfo(href)
|
|
attr = typeinfo.GetTypeAttr()
|
|
if typecomp is None:
|
|
olerepr = build.DispatchItem(typeinfo, attr, None, 0)
|
|
else:
|
|
olerepr = build.LazyDispatchItem(attr, None)
|
|
except pythoncom.ole_error:
|
|
pass
|
|
if olerepr is None: olerepr = build.DispatchItem()
|
|
return olerepr
|
|
|
|
def DumbDispatch(IDispatch, userName = None, createClass = None,UnicodeToString=None, clsctx=pythoncom.CLSCTX_SERVER):
|
|
"Dispatch with no type info"
|
|
assert UnicodeToString is None, "this is deprecated and will go away"
|
|
IDispatch, userName = _GetGoodDispatchAndUserName(IDispatch,userName,clsctx)
|
|
if createClass is None:
|
|
createClass = CDispatch
|
|
return createClass(IDispatch, build.DispatchItem(), userName)
|
|
|
|
class CDispatch:
|
|
def __init__(self, IDispatch, olerepr, userName=None, UnicodeToString=None, lazydata=None):
|
|
assert UnicodeToString is None, "this is deprecated and will go away"
|
|
if userName is None: userName = "<unknown>"
|
|
self.__dict__['_oleobj_'] = IDispatch
|
|
self.__dict__['_username_'] = userName
|
|
self.__dict__['_olerepr_'] = olerepr
|
|
self.__dict__['_mapCachedItems_'] = {}
|
|
self.__dict__['_builtMethods_'] = {}
|
|
self.__dict__['_enum_'] = None
|
|
self.__dict__['_unicode_to_string_'] = None
|
|
self.__dict__['_lazydata_'] = lazydata
|
|
|
|
def __call__(self, *args):
|
|
"Provide 'default dispatch' COM functionality - allow instance to be called"
|
|
if self._olerepr_.defaultDispatchName:
|
|
invkind, dispid = self._find_dispatch_type_(self._olerepr_.defaultDispatchName)
|
|
else:
|
|
invkind, dispid = pythoncom.DISPATCH_METHOD | pythoncom.DISPATCH_PROPERTYGET, pythoncom.DISPID_VALUE
|
|
if invkind is not None:
|
|
allArgs = (dispid,LCID,invkind,1) + args
|
|
return self._get_good_object_(self._oleobj_.Invoke(*allArgs),self._olerepr_.defaultDispatchName,None)
|
|
raise TypeError("This dispatch object does not define a default method")
|
|
|
|
def __bool__(self):
|
|
return True # ie "if object:" should always be "true" - without this, __len__ is tried.
|
|
# _Possibly_ want to defer to __len__ if available, but Im not sure this is
|
|
# desirable???
|
|
|
|
def __repr__(self):
|
|
return "<COMObject %s>" % (self._username_)
|
|
|
|
def __str__(self):
|
|
# __str__ is used when the user does "print object", so we gracefully
|
|
# fall back to the __repr__ if the object has no default method.
|
|
try:
|
|
return str(self.__call__())
|
|
except pythoncom.com_error as details:
|
|
if details.hresult not in ERRORS_BAD_CONTEXT:
|
|
raise
|
|
return self.__repr__()
|
|
|
|
# Delegate comparison to the oleobjs, as they know how to do identity.
|
|
def __eq__(self, other):
|
|
other = getattr(other, "_oleobj_", other)
|
|
return self._oleobj_ == other
|
|
|
|
def __ne__(self, other):
|
|
other = getattr(other, "_oleobj_", other)
|
|
return self._oleobj_ != other
|
|
|
|
def __int__(self):
|
|
return int(self.__call__())
|
|
|
|
def __len__(self):
|
|
invkind, dispid = self._find_dispatch_type_("Count")
|
|
if invkind:
|
|
return self._oleobj_.Invoke(dispid, LCID, invkind, 1)
|
|
raise TypeError("This dispatch object does not define a Count method")
|
|
|
|
def _NewEnum(self):
|
|
try:
|
|
invkind = pythoncom.DISPATCH_METHOD | pythoncom.DISPATCH_PROPERTYGET
|
|
enum = self._oleobj_.InvokeTypes(pythoncom.DISPID_NEWENUM,LCID,invkind,(13, 10),())
|
|
except pythoncom.com_error:
|
|
return None # no enumerator for this object.
|
|
from . import util
|
|
return util.WrapEnum(enum, None)
|
|
|
|
def __getitem__(self, index): # syver modified
|
|
# Improved __getitem__ courtesy Syver Enstad
|
|
# Must check _NewEnum before Item, to ensure b/w compat.
|
|
if isinstance(index, int):
|
|
if self.__dict__['_enum_'] is None:
|
|
self.__dict__['_enum_'] = self._NewEnum()
|
|
if self.__dict__['_enum_'] is not None:
|
|
return self._get_good_object_(self._enum_.__getitem__(index))
|
|
# See if we have an "Item" method/property we can use (goes hand in hand with Count() above!)
|
|
invkind, dispid = self._find_dispatch_type_("Item")
|
|
if invkind is not None:
|
|
return self._get_good_object_(self._oleobj_.Invoke(dispid, LCID, invkind, 1, index))
|
|
raise TypeError("This object does not support enumeration")
|
|
|
|
def __setitem__(self, index, *args):
|
|
# XXX - todo - We should support calling Item() here too!
|
|
# print "__setitem__ with", index, args
|
|
if self._olerepr_.defaultDispatchName:
|
|
invkind, dispid = self._find_dispatch_type_(self._olerepr_.defaultDispatchName)
|
|
else:
|
|
invkind, dispid = pythoncom.DISPATCH_PROPERTYPUT | pythoncom.DISPATCH_PROPERTYPUTREF, pythoncom.DISPID_VALUE
|
|
if invkind is not None:
|
|
allArgs = (dispid,LCID,invkind,0,index) + args
|
|
return self._get_good_object_(self._oleobj_.Invoke(*allArgs),self._olerepr_.defaultDispatchName,None)
|
|
raise TypeError("This dispatch object does not define a default method")
|
|
|
|
def _find_dispatch_type_(self, methodName):
|
|
if methodName in self._olerepr_.mapFuncs:
|
|
item = self._olerepr_.mapFuncs[methodName]
|
|
return item.desc[4], item.dispid
|
|
|
|
if methodName in self._olerepr_.propMapGet:
|
|
item = self._olerepr_.propMapGet[methodName]
|
|
return item.desc[4], item.dispid
|
|
|
|
try:
|
|
dispid = self._oleobj_.GetIDsOfNames(0,methodName)
|
|
except: ### what error?
|
|
return None, None
|
|
return pythoncom.DISPATCH_METHOD | pythoncom.DISPATCH_PROPERTYGET, dispid
|
|
|
|
def _ApplyTypes_(self, dispid, wFlags, retType, argTypes, user, resultCLSID, *args):
|
|
result = self._oleobj_.InvokeTypes(*(dispid, LCID, wFlags, retType, argTypes) + args)
|
|
return self._get_good_object_(result, user, resultCLSID)
|
|
|
|
def _wrap_dispatch_(self, ob, userName = None, returnCLSID = None, UnicodeToString=None):
|
|
# Given a dispatch object, wrap it in a class
|
|
assert UnicodeToString is None, "this is deprecated and will go away"
|
|
return Dispatch(ob, userName)
|
|
|
|
def _get_good_single_object_(self,ob,userName = None, ReturnCLSID=None):
|
|
if isinstance(ob, PyIDispatchType):
|
|
# make a new instance of (probably this) class.
|
|
return self._wrap_dispatch_(ob, userName, ReturnCLSID)
|
|
if isinstance(ob, PyIUnknownType):
|
|
try:
|
|
ob = ob.QueryInterface(pythoncom.IID_IDispatch)
|
|
except pythoncom.com_error:
|
|
# It is an IUnknown, but not an IDispatch, so just let it through.
|
|
return ob
|
|
return self._wrap_dispatch_(ob, userName, ReturnCLSID)
|
|
return ob
|
|
|
|
def _get_good_object_(self,ob,userName = None, ReturnCLSID=None):
|
|
"""Given an object (usually the retval from a method), make it a good object to return.
|
|
Basically checks if it is a COM object, and wraps it up.
|
|
Also handles the fact that a retval may be a tuple of retvals"""
|
|
if ob is None: # Quick exit!
|
|
return None
|
|
elif isinstance(ob, tuple):
|
|
return tuple(map(lambda o, s=self, oun=userName, rc=ReturnCLSID: s._get_good_single_object_(o, oun, rc), ob))
|
|
else:
|
|
return self._get_good_single_object_(ob)
|
|
|
|
def _make_method_(self, name):
|
|
"Make a method object - Assumes in olerepr funcmap"
|
|
methodName = build.MakePublicAttributeName(name) # translate keywords etc.
|
|
methodCodeList = self._olerepr_.MakeFuncMethod(self._olerepr_.mapFuncs[name], methodName,0)
|
|
methodCode = "\n".join(methodCodeList)
|
|
try:
|
|
# print "Method code for %s is:\n" % self._username_, methodCode
|
|
# self._print_details_()
|
|
codeObject = compile(methodCode, "<COMObject %s>" % self._username_,"exec")
|
|
# Exec the code object
|
|
tempNameSpace = {}
|
|
# "Dispatch" in the exec'd code is win32com.client.Dispatch, not ours.
|
|
globNameSpace = globals().copy()
|
|
globNameSpace["Dispatch"] = win32com.client.Dispatch
|
|
exec(codeObject, globNameSpace, tempNameSpace) # self.__dict__, self.__dict__
|
|
name = methodName
|
|
# Save the function in map.
|
|
fn = self._builtMethods_[name] = tempNameSpace[name]
|
|
newMeth = MakeMethod(fn, self, self.__class__)
|
|
return newMeth
|
|
except:
|
|
debug_print("Error building OLE definition for code ", methodCode)
|
|
traceback.print_exc()
|
|
return None
|
|
|
|
def _Release_(self):
|
|
"""Cleanup object - like a close - to force cleanup when you dont
|
|
want to rely on Python's reference counting."""
|
|
for childCont in self._mapCachedItems_.values():
|
|
childCont._Release_()
|
|
self._mapCachedItems_ = {}
|
|
if self._oleobj_:
|
|
self._oleobj_.Release()
|
|
self.__dict__['_oleobj_'] = None
|
|
if self._olerepr_:
|
|
self.__dict__['_olerepr_'] = None
|
|
self._enum_ = None
|
|
|
|
def _proc_(self, name, *args):
|
|
"""Call the named method as a procedure, rather than function.
|
|
Mainly used by Word.Basic, which whinges about such things."""
|
|
try:
|
|
item = self._olerepr_.mapFuncs[name]
|
|
dispId = item.dispid
|
|
return self._get_good_object_(self._oleobj_.Invoke(*(dispId, LCID, item.desc[4], 0) + (args) ))
|
|
except KeyError:
|
|
raise AttributeError(name)
|
|
|
|
def _print_details_(self):
|
|
"Debug routine - dumps what it knows about an object."
|
|
print("AxDispatch container",self._username_)
|
|
try:
|
|
print("Methods:")
|
|
for method in self._olerepr_.mapFuncs.keys():
|
|
print("\t", method)
|
|
print("Props:")
|
|
for prop, entry in self._olerepr_.propMap.items():
|
|
print("\t%s = 0x%x - %s" % (prop, entry.dispid, repr(entry)))
|
|
print("Get Props:")
|
|
for prop, entry in self._olerepr_.propMapGet.items():
|
|
print("\t%s = 0x%x - %s" % (prop, entry.dispid, repr(entry)))
|
|
print("Put Props:")
|
|
for prop, entry in self._olerepr_.propMapPut.items():
|
|
print("\t%s = 0x%x - %s" % (prop, entry.dispid, repr(entry)))
|
|
except:
|
|
traceback.print_exc()
|
|
|
|
def __LazyMap__(self, attr):
|
|
try:
|
|
if self._LazyAddAttr_(attr):
|
|
debug_attr_print("%s.__LazyMap__(%s) added something" % (self._username_,attr))
|
|
return 1
|
|
except AttributeError:
|
|
return 0
|
|
|
|
# Using the typecomp, lazily create a new attribute definition.
|
|
def _LazyAddAttr_(self,attr):
|
|
if self._lazydata_ is None: return 0
|
|
res = 0
|
|
typeinfo, typecomp = self._lazydata_
|
|
olerepr = self._olerepr_
|
|
# We need to explicitly check each invoke type individually - simply
|
|
# specifying '0' will bind to "any member", which may not be the one
|
|
# we are actually after (ie, we may be after prop_get, but returned
|
|
# the info for the prop_put.)
|
|
for i in ALL_INVOKE_TYPES:
|
|
try:
|
|
x,t = typecomp.Bind(attr,i)
|
|
# Support 'Get' and 'Set' properties - see
|
|
# bug 1587023
|
|
if x==0 and attr[:3] in ('Set', 'Get'):
|
|
x,t = typecomp.Bind(attr[3:], i)
|
|
if x==1: #it's a FUNCDESC
|
|
r = olerepr._AddFunc_(typeinfo,t,0)
|
|
elif x==2: #it's a VARDESC
|
|
r = olerepr._AddVar_(typeinfo,t,0)
|
|
else: #not found or TYPEDESC/IMPLICITAPP
|
|
r=None
|
|
if not r is None:
|
|
key, map = r[0],r[1]
|
|
item = map[key]
|
|
if map==olerepr.propMapPut:
|
|
olerepr._propMapPutCheck_(key,item)
|
|
elif map==olerepr.propMapGet:
|
|
olerepr._propMapGetCheck_(key,item)
|
|
res = 1
|
|
except:
|
|
pass
|
|
return res
|
|
|
|
def _FlagAsMethod(self, *methodNames):
|
|
"""Flag these attribute names as being methods.
|
|
Some objects do not correctly differentiate methods and
|
|
properties, leading to problems when calling these methods.
|
|
|
|
Specifically, trying to say: ob.SomeFunc()
|
|
may yield an exception "None object is not callable"
|
|
In this case, an attempt to fetch the *property*has worked
|
|
and returned None, rather than indicating it is really a method.
|
|
Calling: ob._FlagAsMethod("SomeFunc")
|
|
should then allow this to work.
|
|
"""
|
|
for name in methodNames:
|
|
details = build.MapEntry(self.__AttrToID__(name), (name,))
|
|
self._olerepr_.mapFuncs[name] = details
|
|
|
|
def __AttrToID__(self,attr):
|
|
debug_attr_print("Calling GetIDsOfNames for property %s in Dispatch container %s" % (attr, self._username_))
|
|
return self._oleobj_.GetIDsOfNames(0,attr)
|
|
|
|
def __getattr__(self, attr):
|
|
if attr=='__iter__':
|
|
# We can't handle this as a normal method, as if the attribute
|
|
# exists, then it must return an iterable object.
|
|
try:
|
|
invkind = pythoncom.DISPATCH_METHOD | pythoncom.DISPATCH_PROPERTYGET
|
|
enum = self._oleobj_.InvokeTypes(pythoncom.DISPID_NEWENUM,LCID,invkind,(13, 10),())
|
|
except pythoncom.com_error:
|
|
raise AttributeError("This object can not function as an iterator")
|
|
# We must return a callable object.
|
|
class Factory:
|
|
def __init__(self, ob):
|
|
self.ob = ob
|
|
def __call__(self):
|
|
import win32com.client.util
|
|
return win32com.client.util.Iterator(self.ob)
|
|
return Factory(enum)
|
|
|
|
if attr.startswith('_') and attr.endswith('_'): # Fast-track.
|
|
raise AttributeError(attr)
|
|
# If a known method, create new instance and return.
|
|
try:
|
|
return MakeMethod(self._builtMethods_[attr], self, self.__class__)
|
|
except KeyError:
|
|
pass
|
|
# XXX - Note that we current are case sensitive in the method.
|
|
#debug_attr_print("GetAttr called for %s on DispatchContainer %s" % (attr,self._username_))
|
|
# First check if it is in the method map. Note that an actual method
|
|
# must not yet exist, (otherwise we would not be here). This
|
|
# means we create the actual method object - which also means
|
|
# this code will never be asked for that method name again.
|
|
if attr in self._olerepr_.mapFuncs:
|
|
return self._make_method_(attr)
|
|
|
|
# Delegate to property maps/cached items
|
|
retEntry = None
|
|
if self._olerepr_ and self._oleobj_:
|
|
# first check general property map, then specific "put" map.
|
|
retEntry = self._olerepr_.propMap.get(attr)
|
|
if retEntry is None:
|
|
retEntry = self._olerepr_.propMapGet.get(attr)
|
|
# Not found so far - See what COM says.
|
|
if retEntry is None:
|
|
try:
|
|
if self.__LazyMap__(attr):
|
|
if attr in self._olerepr_.mapFuncs: return self._make_method_(attr)
|
|
retEntry = self._olerepr_.propMap.get(attr)
|
|
if retEntry is None:
|
|
retEntry = self._olerepr_.propMapGet.get(attr)
|
|
if retEntry is None:
|
|
retEntry = build.MapEntry(self.__AttrToID__(attr), (attr,))
|
|
except pythoncom.ole_error:
|
|
pass # No prop by that name - retEntry remains None.
|
|
|
|
if not retEntry is None: # see if in my cache
|
|
try:
|
|
ret = self._mapCachedItems_[retEntry.dispid]
|
|
debug_attr_print ("Cached items has attribute!", ret)
|
|
return ret
|
|
except (KeyError, AttributeError):
|
|
debug_attr_print("Attribute %s not in cache" % attr)
|
|
|
|
# If we are still here, and have a retEntry, get the OLE item
|
|
if not retEntry is None:
|
|
invoke_type = _GetDescInvokeType(retEntry, pythoncom.INVOKE_PROPERTYGET)
|
|
debug_attr_print("Getting property Id 0x%x from OLE object" % retEntry.dispid)
|
|
try:
|
|
ret = self._oleobj_.Invoke(retEntry.dispid,0,invoke_type,1)
|
|
except pythoncom.com_error as details:
|
|
if details.hresult in ERRORS_BAD_CONTEXT:
|
|
# May be a method.
|
|
self._olerepr_.mapFuncs[attr] = retEntry
|
|
return self._make_method_(attr)
|
|
raise
|
|
debug_attr_print("OLE returned ", ret)
|
|
return self._get_good_object_(ret)
|
|
|
|
# no where else to look.
|
|
raise AttributeError("%s.%s" % (self._username_, attr))
|
|
|
|
def __setattr__(self, attr, value):
|
|
if attr in self.__dict__: # Fast-track - if already in our dict, just make the assignment.
|
|
# XXX - should maybe check method map - if someone assigns to a method,
|
|
# it could mean something special (not sure what, tho!)
|
|
self.__dict__[attr] = value
|
|
return
|
|
# Allow property assignment.
|
|
debug_attr_print("SetAttr called for %s.%s=%s on DispatchContainer" % (self._username_, attr, repr(value)))
|
|
|
|
if self._olerepr_:
|
|
# Check the "general" property map.
|
|
if attr in self._olerepr_.propMap:
|
|
entry = self._olerepr_.propMap[attr]
|
|
invoke_type = _GetDescInvokeType(entry, pythoncom.INVOKE_PROPERTYPUT)
|
|
self._oleobj_.Invoke(entry.dispid, 0, invoke_type, 0, value)
|
|
return
|
|
# Check the specific "put" map.
|
|
if attr in self._olerepr_.propMapPut:
|
|
entry = self._olerepr_.propMapPut[attr]
|
|
invoke_type = _GetDescInvokeType(entry, pythoncom.INVOKE_PROPERTYPUT)
|
|
self._oleobj_.Invoke(entry.dispid, 0, invoke_type, 0, value)
|
|
return
|
|
|
|
# Try the OLE Object
|
|
if self._oleobj_:
|
|
if self.__LazyMap__(attr):
|
|
# Check the "general" property map.
|
|
if attr in self._olerepr_.propMap:
|
|
entry = self._olerepr_.propMap[attr]
|
|
invoke_type = _GetDescInvokeType(entry, pythoncom.INVOKE_PROPERTYPUT)
|
|
self._oleobj_.Invoke(entry.dispid, 0, invoke_type, 0, value)
|
|
return
|
|
# Check the specific "put" map.
|
|
if attr in self._olerepr_.propMapPut:
|
|
entry = self._olerepr_.propMapPut[attr]
|
|
invoke_type = _GetDescInvokeType(entry, pythoncom.INVOKE_PROPERTYPUT)
|
|
self._oleobj_.Invoke(entry.dispid, 0, invoke_type, 0, value)
|
|
return
|
|
try:
|
|
entry = build.MapEntry(self.__AttrToID__(attr),(attr,))
|
|
except pythoncom.com_error:
|
|
# No attribute of that name
|
|
entry = None
|
|
if entry is not None:
|
|
try:
|
|
invoke_type = _GetDescInvokeType(entry, pythoncom.INVOKE_PROPERTYPUT)
|
|
self._oleobj_.Invoke(entry.dispid, 0, invoke_type, 0, value)
|
|
self._olerepr_.propMap[attr] = entry
|
|
debug_attr_print("__setattr__ property %s (id=0x%x) in Dispatch container %s" % (attr, entry.dispid, self._username_))
|
|
return
|
|
except pythoncom.com_error:
|
|
pass
|
|
raise AttributeError("Property '%s.%s' can not be set." % (self._username_, attr))
|