| """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) |