First checkin of the Python XPCOM bindings.
git-svn-id: svn://10.0.0.236/trunk@87331 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
markh%activestate.com
247
mozilla/extensions/python/xpcom/client/__init__.py
Normal file
247
mozilla/extensions/python/xpcom/client/__init__.py
Normal file
@@ -0,0 +1,247 @@
|
||||
# Copyright (c) 2000-2001 ActiveState Tool Corporation.
|
||||
# See the file LICENSE.txt for licensing information.
|
||||
|
||||
import os
|
||||
import new
|
||||
from xpcom import xpt, _xpcom, COMException, nsError
|
||||
|
||||
XPTC_InvokeByIndex = _xpcom.XPTC_InvokeByIndex
|
||||
|
||||
_just_int_interfaces = ["nsISupportsPRInt32", "nsISupportsPRInt16", "nsISupportsPRUint32", "nsISupportsPRUint16", "nsISupportsPRUint8", "nsISupportsPRBool"]
|
||||
_just_long_interfaces = ["nsISupportsPRInt64", "nsISupportsPRUint64"]
|
||||
_just_float_interfaces = ["nsISupportsDouble", "nsISupportsFloat"]
|
||||
# When doing a specific conversion, the order we try the interfaces in.
|
||||
_int_interfaces = _just_int_interfaces + _just_float_interfaces
|
||||
_long_interfaces = _just_long_interfaces + _just_int_interfaces + _just_float_interfaces
|
||||
_float_interfaces = _just_float_interfaces + _just_long_interfaces + _just_int_interfaces
|
||||
|
||||
method_template = """
|
||||
def %s(self, %s):
|
||||
return XPTC_InvokeByIndex(self._comobj_, %d,
|
||||
(%s,
|
||||
(%s)))
|
||||
"""
|
||||
def _MakeMethodCode(method):
|
||||
# Build a declaration
|
||||
param_no = 0
|
||||
param_decls = []
|
||||
param_flags = []
|
||||
param_names = []
|
||||
used_default = 0
|
||||
for param in method.params:
|
||||
param_no = param_no + 1
|
||||
param_name = "Param%d" % (param_no,)
|
||||
param_default = ""
|
||||
if not param.hidden_indicator and param.IsIn() and not param.IsDipper():
|
||||
if param.IsOut() or used_default: # If the param is "inout", provide a useful default for the "in" direction.
|
||||
param_default = " = None"
|
||||
used_default = 1 # Once we have used one once, we must for the rest!
|
||||
param_decls.append(param_name + param_default)
|
||||
param_names.append(param_name)
|
||||
|
||||
type_repr = xpt.MakeReprForInvoke(param)
|
||||
param_flags.append( (param.param_flags,) + type_repr )
|
||||
sep = ", "
|
||||
param_decls = sep.join(param_decls)
|
||||
if len(param_names)==1: # Damn tuple reprs.
|
||||
param_names = param_names[0] + ","
|
||||
else:
|
||||
param_names = sep.join(param_names)
|
||||
# A couple of extra newlines make them easier to read for debugging :-)
|
||||
return method_template % (method.name, param_decls, method.method_index, tuple(param_flags), param_names)
|
||||
|
||||
# Keyed by IID, each item is a tuple of (methods, getters, setters)
|
||||
interface_cache = {}
|
||||
|
||||
# Fully process the interface - generate method code, etc.
|
||||
def BuildInterfaceInfo(iid):
|
||||
ret = interface_cache.get(iid, None)
|
||||
if ret is None:
|
||||
# Build the data for the cache.
|
||||
method_code_blocks = []
|
||||
getters = {}
|
||||
setters = {}
|
||||
method_names = []
|
||||
|
||||
interface = xpt.Interface(iid)
|
||||
for m in interface.methods:
|
||||
if not m.IsNotXPCOM() and \
|
||||
not m.IsHidden() and \
|
||||
not m.IsConstructor():
|
||||
# Yay - a method we can use!
|
||||
if m.IsSetter():
|
||||
param_flags = map(lambda x: (x.param_flags,) + xpt.MakeReprForInvoke(x), m.params)
|
||||
setters[m.name] = m.method_index, param_flags
|
||||
elif m.IsGetter():
|
||||
param_flags = map(lambda x: (x.param_flags,) + xpt.MakeReprForInvoke(x), m.params)
|
||||
getters[m.name] = m.method_index, param_flags
|
||||
else:
|
||||
method_names.append(m.name)
|
||||
method_code_blocks.append(_MakeMethodCode(m))
|
||||
|
||||
# Build the constants.
|
||||
constants = {}
|
||||
for c in interface.constants:
|
||||
constants[c.name] = c.value
|
||||
# Build the methods - We only build function objects here
|
||||
# - they are bound to each instance at instance creation.
|
||||
methods = {}
|
||||
if len(method_code_blocks)!=0:
|
||||
method_code = "\n".join(method_code_blocks)
|
||||
## print "Method Code:"
|
||||
## print method_code
|
||||
codeObject = compile(method_code, "<XPCOMObject method>","exec")
|
||||
# Exec the code object
|
||||
tempNameSpace = {}
|
||||
exec codeObject in globals(), tempNameSpace # self.__dict__, self.__dict__
|
||||
for name in method_names:
|
||||
methods[name] = tempNameSpace[name]
|
||||
ret = methods, getters, setters, constants
|
||||
interface_cache[iid] = ret
|
||||
return ret
|
||||
|
||||
def Component(ob, iid):
|
||||
ob_name = None
|
||||
if not hasattr(ob, "IID"):
|
||||
ob_name = ob
|
||||
cm = _xpcom.NS_GetGlobalComponentManager()
|
||||
ob = cm.CreateInstanceByContractID(ob)
|
||||
return Interface(ob, iid)
|
||||
|
||||
class Interface:
|
||||
"""Implements a dynamic interface using xpcom reflection.
|
||||
"""
|
||||
def __init__(self, ob, iid, object_name = None):
|
||||
ob = ob.QueryInterface(iid, 0) # zero means "no auto-wrap"
|
||||
self.__dict__['_comobj_'] = ob
|
||||
# Hack - the last interface only!
|
||||
methods, getters, setters, constants = BuildInterfaceInfo(iid)
|
||||
self.__dict__['_interface_infos_'] = getters, setters
|
||||
self.__dict__['_interface_methods_'] = methods # Unbound methods.
|
||||
|
||||
self.__dict__.update(constants)
|
||||
# We remember the constant names to prevent the user trying to assign to them!
|
||||
self.__dict__['_constant_names_'] = constants.keys()
|
||||
|
||||
if object_name is None:
|
||||
object_name = "object with interface '%s'" % (iid.name,)
|
||||
self.__dict__['_object_name_'] = object_name
|
||||
|
||||
def __cmp__(self, other):
|
||||
try:
|
||||
other = other._comobj_
|
||||
except AttributeError:
|
||||
pass
|
||||
return cmp(self._comobj_, other)
|
||||
|
||||
def __hash__(self):
|
||||
return hash(self._comobj_)
|
||||
|
||||
def __repr__(self):
|
||||
return "<XPCOM interface '%s'>" % (self._comobj_.IID.name,)
|
||||
|
||||
# See if the object support strings.
|
||||
def __str__(self):
|
||||
try:
|
||||
self._comobj_.QueryInterface(_xpcom.IID_nsISupportsString)
|
||||
return str(self._comobj_)
|
||||
except COMException:
|
||||
return self.__repr__()
|
||||
|
||||
# Try the numeric support.
|
||||
def _do_conversion(self, interface_names, cvt):
|
||||
iim = _xpcom.XPTI_GetInterfaceInfoManager()
|
||||
for interface_name in interface_names:
|
||||
iid = iim.GetInfoForName(interface_name).GetIID()
|
||||
try:
|
||||
prim = self._comobj_.QueryInterface(iid)
|
||||
return cvt(prim.data)
|
||||
except COMException:
|
||||
pass
|
||||
raise ValueError, "This object does not support automatic numeric conversion to this type"
|
||||
|
||||
def __int__(self):
|
||||
return self._do_conversion(_int_interfaces, int)
|
||||
|
||||
def __long__(self):
|
||||
return self._do_conversion(_long_interfaces, long)
|
||||
|
||||
def __float__(self):
|
||||
return self._do_conversion(_float_interfaces, float)
|
||||
|
||||
def __getattr__(self, attr):
|
||||
# Allow the underlying interface to provide a better implementation if desired.
|
||||
ret = getattr(self.__dict__['_comobj_'], attr, None)
|
||||
if ret is not None:
|
||||
return ret
|
||||
# Do the function thing first.
|
||||
unbound_method = self.__dict__['_interface_methods_'].get(attr)
|
||||
if unbound_method is not None:
|
||||
return new.instancemethod(unbound_method, self, self.__class__)
|
||||
|
||||
getters, setters = self.__dict__['_interface_infos_']
|
||||
info = getters.get(attr)
|
||||
if info is None:
|
||||
raise AttributeError, "XPCOM component '%s' has no attribute '%s'" % (self._object_name_, attr)
|
||||
method_index, param_infos = info
|
||||
if len(param_infos)!=1: # Only expecting a retval
|
||||
raise RuntimeError, "Can't get properties with this many args!"
|
||||
args = ( param_infos, () )
|
||||
return XPTC_InvokeByIndex(self._comobj_, method_index, args)
|
||||
|
||||
def __setattr__(self, attr, val):
|
||||
# If we already have a __dict__ item of that name, and its not one of
|
||||
# our constants, we just directly set it, and leave.
|
||||
if self.__dict__.has_key(attr) and attr not in self.__dict__['_constant_names_']:
|
||||
self.__dict__[attr] = val
|
||||
return
|
||||
# Start sniffing for what sort of attribute this might be?
|
||||
getters, setters = self.__dict__['_interface_infos_']
|
||||
info = setters.get(attr)
|
||||
if info is None:
|
||||
raise AttributeError, "XPCOM component '%s' can not set attribute '%s'" % (self._object_name_, attr)
|
||||
method_index, param_infos = info
|
||||
if len(param_infos)!=1: # Only expecting a single input val
|
||||
raise RuntimeError, "Can't set properties with this many args!"
|
||||
real_param_infos = ( param_infos, (val,) )
|
||||
return XPTC_InvokeByIndex(self._comobj_, method_index, real_param_infos)
|
||||
|
||||
# Called by the _xpcom C++ framework to wrap interfaces up just
|
||||
# before they are returned.
|
||||
def MakeInterfaceResult(ob, iid):
|
||||
return Interface(ob, iid)
|
||||
|
||||
class WeakReference:
|
||||
"""A weak-reference object. You construct a weak reference by passing
|
||||
any COM object you like. If the object does not support weak
|
||||
refs, you will get a standard NS_NOINTERFACE exception.
|
||||
|
||||
Once you have a weak-reference, you can "call" the object to get
|
||||
back a strong reference. Eg:
|
||||
|
||||
>>> some_ob = components.classes['...]
|
||||
>>> weak_ref = WeakReference(some_ob)
|
||||
>>> new_ob = weak_ref() # new_ob is effectively "some_ob" at this point
|
||||
>>> # EXCEPT: new_ob may be None of some_ob has already died - a
|
||||
>>> # weak reference does not keep the object alive (that is the point)
|
||||
|
||||
You should never hold onto this resulting strong object for a long time,
|
||||
or else you defeat the purpose of the weak-reference.
|
||||
"""
|
||||
def __init__(self, ob, iid = None):
|
||||
swr = Interface(ob, _xpcom.IID_nsISupportsWeakReference)
|
||||
self._comobj_ = Interface(swr.GetWeakReference(), _xpcom.IID_nsIWeakReference)
|
||||
if iid is None:
|
||||
try:
|
||||
iid = ob.IID
|
||||
except AttributeError:
|
||||
iid = _xpcom.IID_nsISupports
|
||||
self._iid_ = iid
|
||||
def __call__(self, iid = None):
|
||||
if iid is None: iid = self._iid_
|
||||
try:
|
||||
return Interface(self._comobj_.QueryReferent(iid), iid)
|
||||
except COMException, details:
|
||||
if details.errno != nsError.NS_ERROR_NULL_POINTER:
|
||||
raise
|
||||
return None
|
||||
Reference in New Issue
Block a user