diff options
Diffstat (limited to 'lib/python2.7/plat-mac/aetools.py')
| -rw-r--r-- | lib/python2.7/plat-mac/aetools.py | 363 |
1 files changed, 363 insertions, 0 deletions
diff --git a/lib/python2.7/plat-mac/aetools.py b/lib/python2.7/plat-mac/aetools.py new file mode 100644 index 0000000..41d7a21 --- /dev/null +++ b/lib/python2.7/plat-mac/aetools.py @@ -0,0 +1,363 @@ +"""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) |