/lib-python/2.7/plat-mac/aetools.py
Python | 363 lines | 352 code | 0 blank | 11 comment | 1 complexity | 06566220c7fd13975b19271692f1c1d8 MD5 | raw file
- """Tools for use in AppleEvent clients and servers.
- pack(x) converts a Python object to an AEDesc object
- unpack(desc) does the reverse
- packevent(event, parameters, attributes) sets params and attrs in an AEAppleEvent record
- unpackevent(event) returns the parameters and attributes from an AEAppleEvent record
- Plus... Lots of classes and routines that help representing AE objects,
- ranges, conditionals, logicals, etc., so you can write, e.g.:
- x = Character(1, Document("foobar"))
- and pack(x) will create an AE object reference equivalent to AppleScript's
- character 1 of document "foobar"
- Some of the stuff that appears to be exported from this module comes from other
- files: the pack stuff from aepack, the objects from aetypes.
- """
- from warnings import warnpy3k
- warnpy3k("In 3.x, the aetools module is removed.", stacklevel=2)
- from types import *
- from Carbon import AE
- from Carbon import Evt
- from Carbon import AppleEvents
- import MacOS
- import sys
- import time
- from aetypes import *
- from aepack import packkey, pack, unpack, coerce, AEDescType
- Error = 'aetools.Error'
- # Amount of time to wait for program to be launched
- LAUNCH_MAX_WAIT_TIME=10
- # Special code to unpack an AppleEvent (which is *not* a disguised record!)
- # Note by Jack: No??!? If I read the docs correctly it *is*....
- aekeywords = [
- 'tran',
- 'rtid',
- 'evcl',
- 'evid',
- 'addr',
- 'optk',
- 'timo',
- 'inte', # this attribute is read only - will be set in AESend
- 'esrc', # this attribute is read only
- 'miss', # this attribute is read only
- 'from' # new in 1.0.1
- ]
- def missed(ae):
- try:
- desc = ae.AEGetAttributeDesc('miss', 'keyw')
- except AE.Error, msg:
- return None
- return desc.data
- def unpackevent(ae, formodulename=""):
- parameters = {}
- try:
- dirobj = ae.AEGetParamDesc('----', '****')
- except AE.Error:
- pass
- else:
- parameters['----'] = unpack(dirobj, formodulename)
- del dirobj
- # Workaround for what I feel is a bug in OSX 10.2: 'errn' won't show up in missed...
- try:
- dirobj = ae.AEGetParamDesc('errn', '****')
- except AE.Error:
- pass
- else:
- parameters['errn'] = unpack(dirobj, formodulename)
- del dirobj
- while 1:
- key = missed(ae)
- if not key: break
- parameters[key] = unpack(ae.AEGetParamDesc(key, '****'), formodulename)
- attributes = {}
- for key in aekeywords:
- try:
- desc = ae.AEGetAttributeDesc(key, '****')
- except (AE.Error, MacOS.Error), msg:
- if msg[0] != -1701 and msg[0] != -1704:
- raise
- continue
- attributes[key] = unpack(desc, formodulename)
- return parameters, attributes
- def packevent(ae, parameters = {}, attributes = {}):
- for key, value in parameters.items():
- packkey(ae, key, value)
- for key, value in attributes.items():
- ae.AEPutAttributeDesc(key, pack(value))
- #
- # Support routine for automatically generated Suite interfaces
- # These routines are also useable for the reverse function.
- #
- def keysubst(arguments, keydict):
- """Replace long name keys by their 4-char counterparts, and check"""
- ok = keydict.values()
- for k in arguments.keys():
- if k in keydict:
- v = arguments[k]
- del arguments[k]
- arguments[keydict[k]] = v
- elif k != '----' and k not in ok:
- raise TypeError, 'Unknown keyword argument: %s'%k
- def enumsubst(arguments, key, edict):
- """Substitute a single enum keyword argument, if it occurs"""
- if key not in arguments or edict is None:
- return
- v = arguments[key]
- ok = edict.values()
- if v in edict:
- arguments[key] = Enum(edict[v])
- elif not v in ok:
- raise TypeError, 'Unknown enumerator: %s'%v
- def decodeerror(arguments):
- """Create the 'best' argument for a raise MacOS.Error"""
- errn = arguments['errn']
- err_a1 = errn
- if 'errs' in arguments:
- err_a2 = arguments['errs']
- else:
- err_a2 = MacOS.GetErrorString(errn)
- if 'erob' in arguments:
- err_a3 = arguments['erob']
- else:
- err_a3 = None
- return (err_a1, err_a2, err_a3)
- class TalkTo:
- """An AE connection to an application"""
- _signature = None # Can be overridden by subclasses
- _moduleName = None # Can be overridden by subclasses
- _elemdict = {} # Can be overridden by subclasses
- _propdict = {} # Can be overridden by subclasses
- __eventloop_initialized = 0
- def __ensure_WMAvailable(klass):
- if klass.__eventloop_initialized: return 1
- if not MacOS.WMAvailable(): return 0
- # Workaround for a but in MacOSX 10.2: we must have an event
- # loop before we can call AESend.
- Evt.WaitNextEvent(0,0)
- return 1
- __ensure_WMAvailable = classmethod(__ensure_WMAvailable)
- def __init__(self, signature=None, start=0, timeout=0):
- """Create a communication channel with a particular application.
- Addressing the application is done by specifying either a
- 4-byte signature, an AEDesc or an object that will __aepack__
- to an AEDesc.
- """
- self.target_signature = None
- if signature is None:
- signature = self._signature
- if type(signature) == AEDescType:
- self.target = signature
- elif type(signature) == InstanceType and hasattr(signature, '__aepack__'):
- self.target = signature.__aepack__()
- elif type(signature) == StringType and len(signature) == 4:
- self.target = AE.AECreateDesc(AppleEvents.typeApplSignature, signature)
- self.target_signature = signature
- else:
- raise TypeError, "signature should be 4-char string or AEDesc"
- self.send_flags = AppleEvents.kAEWaitReply
- self.send_priority = AppleEvents.kAENormalPriority
- if timeout:
- self.send_timeout = timeout
- else:
- self.send_timeout = AppleEvents.kAEDefaultTimeout
- if start:
- self._start()
- def _start(self):
- """Start the application, if it is not running yet"""
- try:
- self.send('ascr', 'noop')
- except AE.Error:
- _launch(self.target_signature)
- for i in range(LAUNCH_MAX_WAIT_TIME):
- try:
- self.send('ascr', 'noop')
- except AE.Error:
- pass
- else:
- break
- time.sleep(1)
- def start(self):
- """Deprecated, used _start()"""
- self._start()
- def newevent(self, code, subcode, parameters = {}, attributes = {}):
- """Create a complete structure for an apple event"""
- event = AE.AECreateAppleEvent(code, subcode, self.target,
- AppleEvents.kAutoGenerateReturnID, AppleEvents.kAnyTransactionID)
- packevent(event, parameters, attributes)
- return event
- def sendevent(self, event):
- """Send a pre-created appleevent, await the reply and unpack it"""
- if not self.__ensure_WMAvailable():
- raise RuntimeError, "No window manager access, cannot send AppleEvent"
- reply = event.AESend(self.send_flags, self.send_priority,
- self.send_timeout)
- parameters, attributes = unpackevent(reply, self._moduleName)
- return reply, parameters, attributes
- def send(self, code, subcode, parameters = {}, attributes = {}):
- """Send an appleevent given code/subcode/pars/attrs and unpack the reply"""
- return self.sendevent(self.newevent(code, subcode, parameters, attributes))
- #
- # The following events are somehow "standard" and don't seem to appear in any
- # suite...
- #
- def activate(self):
- """Send 'activate' command"""
- self.send('misc', 'actv')
- def _get(self, _object, asfile=None, _attributes={}):
- """_get: get data from an object
- Required argument: the object
- Keyword argument _attributes: AppleEvent attribute dictionary
- Returns: the data
- """
- _code = 'core'
- _subcode = 'getd'
- _arguments = {'----':_object}
- if asfile:
- _arguments['rtyp'] = mktype(asfile)
- _reply, _arguments, _attributes = self.send(_code, _subcode,
- _arguments, _attributes)
- if 'errn' in _arguments:
- raise Error, decodeerror(_arguments)
- if '----' in _arguments:
- return _arguments['----']
- if asfile:
- item.__class__ = asfile
- return item
- get = _get
- _argmap_set = {
- 'to' : 'data',
- }
- def _set(self, _object, _attributes={}, **_arguments):
- """set: Set an object's data.
- Required argument: the object for the command
- Keyword argument to: The new value.
- Keyword argument _attributes: AppleEvent attribute dictionary
- """
- _code = 'core'
- _subcode = 'setd'
- keysubst(_arguments, self._argmap_set)
- _arguments['----'] = _object
- _reply, _arguments, _attributes = self.send(_code, _subcode,
- _arguments, _attributes)
- if _arguments.get('errn', 0):
- raise Error, decodeerror(_arguments)
- # XXXX Optionally decode result
- if '----' in _arguments:
- return _arguments['----']
- set = _set
- # Magic glue to allow suite-generated classes to function somewhat
- # like the "application" class in OSA.
- def __getattr__(self, name):
- if name in self._elemdict:
- cls = self._elemdict[name]
- return DelayedComponentItem(cls, None)
- if name in self._propdict:
- cls = self._propdict[name]
- return cls()
- raise AttributeError, name
- # Tiny Finder class, for local use only
- class _miniFinder(TalkTo):
- def open(self, _object, _attributes={}, **_arguments):
- """open: Open the specified object(s)
- Required argument: list of objects to open
- Keyword argument _attributes: AppleEvent attribute dictionary
- """
- _code = 'aevt'
- _subcode = 'odoc'
- if _arguments: raise TypeError, 'No optional args expected'
- _arguments['----'] = _object
- _reply, _arguments, _attributes = self.send(_code, _subcode,
- _arguments, _attributes)
- if 'errn' in _arguments:
- raise Error, decodeerror(_arguments)
- # XXXX Optionally decode result
- if '----' in _arguments:
- return _arguments['----']
- #pass
- _finder = _miniFinder('MACS')
- def _launch(appfile):
- """Open a file thru the finder. Specify file by name or fsspec"""
- _finder.open(_application_file(('ID ', appfile)))
- class _application_file(ComponentItem):
- """application file - An application's file on disk"""
- want = 'appf'
- _application_file._propdict = {
- }
- _application_file._elemdict = {
- }
- # Test program
- # XXXX Should test more, really...
- def test():
- target = AE.AECreateDesc('sign', 'quil')
- ae = AE.AECreateAppleEvent('aevt', 'oapp', target, -1, 0)
- print unpackevent(ae)
- raw_input(":")
- ae = AE.AECreateAppleEvent('core', 'getd', target, -1, 0)
- obj = Character(2, Word(1, Document(1)))
- print obj
- print repr(obj)
- packevent(ae, {'----': obj})
- params, attrs = unpackevent(ae)
- print params['----']
- raw_input(":")
- if __name__ == '__main__':
- test()
- sys.exit(1)