1 """Tools for use in AppleEvent clients and servers: 2 conversion between AE types and python types 3 4 pack(x) converts a Python object to an AEDesc object 5 unpack(desc) does the reverse 6 coerce(x, wanted_sample) coerces a python object to another python object 7 """ 8 9 # 10 # This code was originally written by Guido, and modified/extended by Jack 11 # to include the various types that were missing. The reference used is 12 # Apple Event Registry, chapter 9. 13 # 14 15 from warnings import warnpy3k 16 warnpy3k("In 3.x, the aepack module is removed.", stacklevel=2) 17 18 import struct 19 import types 20 from types import * 21 from Carbon import AE 22 from Carbon.AppleEvents import * 23 import MacOS 24 import Carbon.File 25 import aetypes 26 from aetypes import mkenum, ObjectSpecifier 27 28 # These ones seem to be missing from AppleEvents 29 # (they're in AERegistry.h) 30 31 #typeColorTable = 'clrt' 32 #typeDrawingArea = 'cdrw' 33 #typePixelMap = 'cpix' 34 #typePixelMapMinus = 'tpmm' 35 #typeRotation = 'trot' 36 #typeTextStyles = 'tsty' 37 #typeStyledText = 'STXT' 38 #typeAEText = 'tTXT' 39 #typeEnumeration = 'enum' 40 41 # 42 # Some AE types are immedeately coerced into something 43 # we like better (and which is equivalent) 44 # 45 unpacker_coercions = { 46 typeComp : typeFloat, 47 typeColorTable : typeAEList, 48 typeDrawingArea : typeAERecord, 49 typeFixed : typeFloat, 50 typeExtended : typeFloat, 51 typePixelMap : typeAERecord, 52 typeRotation : typeAERecord, 53 typeStyledText : typeAERecord, 54 typeTextStyles : typeAERecord, 55 }; 56 57 # 58 # Some python types we need in the packer: 59 # 60 AEDescType = AE.AEDescType 61 try: 62 FSSType = Carbon.File.FSSpecType 63 except AttributeError: 64 class FSSType: 65 pass 66 FSRefType = Carbon.File.FSRefType 67 AliasType = Carbon.File.AliasType 68 69 def packkey(ae, key, value): 70 if hasattr(key, 'which'): 71 keystr = key.which 72 elif hasattr(key, 'want'): 73 keystr = key.want 74 else: 75 keystr = key 76 ae.AEPutParamDesc(keystr, pack(value)) 77 78 def pack(x, forcetype = None): 79 """Pack a python object into an AE descriptor""" 80 81 if forcetype: 82 if type(x) is StringType: 83 return AE.AECreateDesc(forcetype, x) 84 else: 85 return pack(x).AECoerceDesc(forcetype) 86 87 if x is None: 88 return AE.AECreateDesc('null', '') 89 90 if isinstance(x, AEDescType): 91 return x 92 if isinstance(x, FSSType): 93 return AE.AECreateDesc('fss ', x.data) 94 if isinstance(x, FSRefType): 95 return AE.AECreateDesc('fsrf', x.data) 96 if isinstance(x, AliasType): 97 return AE.AECreateDesc('alis', x.data) 98 if isinstance(x, IntType): 99 return AE.AECreateDesc('long', struct.pack('l', x)) 100 if isinstance(x, FloatType): 101 return AE.AECreateDesc('doub', struct.pack('d', x)) 102 if isinstance(x, StringType): 103 return AE.AECreateDesc('TEXT', x) 104 if isinstance(x, UnicodeType): 105 data = x.encode('utf16') 106 if data[:2] == '\xfe\xff': 107 data = data[2:] 108 return AE.AECreateDesc('utxt', data) 109 if isinstance(x, ListType): 110 list = AE.AECreateList('', 0) 111 for item in x: 112 list.AEPutDesc(0, pack(item)) 113 return list 114 if isinstance(x, DictionaryType): 115 record = AE.AECreateList('', 1) 116 for key, value in x.items(): 117 packkey(record, key, value) 118 #record.AEPutParamDesc(key, pack(value)) 119 return record 120 if type(x) == types.ClassType and issubclass(x, ObjectSpecifier): 121 # Note: we are getting a class object here, not an instance 122 return AE.AECreateDesc('type', x.want) 123 if hasattr(x, '__aepack__'): 124 return x.__aepack__() 125 if hasattr(x, 'which'): 126 return AE.AECreateDesc('TEXT', x.which) 127 if hasattr(x, 'want'): 128 return AE.AECreateDesc('TEXT', x.want) 129 return AE.AECreateDesc('TEXT', repr(x)) # Copout 130 131 def unpack(desc, formodulename=""): 132 """Unpack an AE descriptor to a python object""" 133 t = desc.type 134 135 if t in unpacker_coercions: 136 desc = desc.AECoerceDesc(unpacker_coercions[t]) 137 t = desc.type # This is a guess by Jack.... 138 139 if t == typeAEList: 140 l = [] 141 for i in range(desc.AECountItems()): 142 keyword, item = desc.AEGetNthDesc(i+1, '****') 143 l.append(unpack(item, formodulename)) 144 return l 145 if t == typeAERecord: 146 d = {} 147 for i in range(desc.AECountItems()): 148 keyword, item = desc.AEGetNthDesc(i+1, '****') 149 d[keyword] = unpack(item, formodulename) 150 return d 151 if t == typeAEText: 152 record = desc.AECoerceDesc('reco') 153 return mkaetext(unpack(record, formodulename)) 154 if t == typeAlias: 155 return Carbon.File.Alias(rawdata=desc.data) 156 # typeAppleEvent returned as unknown 157 if t == typeBoolean: 158 return struct.unpack('b', desc.data)[0] 159 if t == typeChar: 160 return desc.data 161 if t == typeUnicodeText: 162 return unicode(desc.data, 'utf16') 163 # typeColorTable coerced to typeAEList 164 # typeComp coerced to extended 165 # typeData returned as unknown 166 # typeDrawingArea coerced to typeAERecord 167 if t == typeEnumeration: 168 return mkenum(desc.data) 169 # typeEPS returned as unknown 170 if t == typeFalse: 171 return 0 172 if t == typeFloat: 173 data = desc.data 174 return struct.unpack('d', data)[0] 175 if t == typeFSS: 176 return Carbon.File.FSSpec(rawdata=desc.data) 177 if t == typeFSRef: 178 return Carbon.File.FSRef(rawdata=desc.data) 179 if t == typeInsertionLoc: 180 record = desc.AECoerceDesc('reco') 181 return mkinsertionloc(unpack(record, formodulename)) 182 # typeInteger equal to typeLongInteger 183 if t == typeIntlText: 184 script, language = struct.unpack('hh', desc.data[:4]) 185 return aetypes.IntlText(script, language, desc.data[4:]) 186 if t == typeIntlWritingCode: 187 script, language = struct.unpack('hh', desc.data) 188 return aetypes.IntlWritingCode(script, language) 189 if t == typeKeyword: 190 return mkkeyword(desc.data) 191 if t == typeLongInteger: 192 return struct.unpack('l', desc.data)[0] 193 if t == typeLongDateTime: 194 a, b = struct.unpack('lL', desc.data) 195 return (long(a) << 32) + b 196 if t == typeNull: 197 return None 198 if t == typeMagnitude: 199 v = struct.unpack('l', desc.data) 200 if v < 0: 201 v = 0x100000000L + v 202 return v 203 if t == typeObjectSpecifier: 204 record = desc.AECoerceDesc('reco') 205 # If we have been told the name of the module we are unpacking aedescs for, 206 # we can attempt to create the right type of python object from that module. 207 if formodulename: 208 return mkobjectfrommodule(unpack(record, formodulename), formodulename) 209 return mkobject(unpack(record, formodulename)) 210 # typePict returned as unknown 211 # typePixelMap coerced to typeAERecord 212 # typePixelMapMinus returned as unknown 213 # typeProcessSerialNumber returned as unknown 214 if t == typeQDPoint: 215 v, h = struct.unpack('hh', desc.data) 216 return aetypes.QDPoint(v, h) 217 if t == typeQDRectangle: 218 v0, h0, v1, h1 = struct.unpack('hhhh', desc.data) 219 return aetypes.QDRectangle(v0, h0, v1, h1) 220 if t == typeRGBColor: 221 r, g, b = struct.unpack('hhh', desc.data) 222 return aetypes.RGBColor(r, g, b) 223 # typeRotation coerced to typeAERecord 224 # typeScrapStyles returned as unknown 225 # typeSessionID returned as unknown 226 if t == typeShortFloat: 227 return struct.unpack('f', desc.data)[0] 228 if t == typeShortInteger: 229 return struct.unpack('h', desc.data)[0] 230 # typeSMFloat identical to typeShortFloat 231 # typeSMInt indetical to typeShortInt 232 # typeStyledText coerced to typeAERecord 233 if t == typeTargetID: 234 return mktargetid(desc.data) 235 # typeTextStyles coerced to typeAERecord 236 # typeTIFF returned as unknown 237 if t == typeTrue: 238 return 1 239 if t == typeType: 240 return mktype(desc.data, formodulename) 241 # 242 # The following are special 243 # 244 if t == 'rang': 245 record = desc.AECoerceDesc('reco') 246 return mkrange(unpack(record, formodulename)) 247 if t == 'cmpd': 248 record = desc.AECoerceDesc('reco') 249 return mkcomparison(unpack(record, formodulename)) 250 if t == 'logi': 251 record = desc.AECoerceDesc('reco') 252 return mklogical(unpack(record, formodulename)) 253 return mkunknown(desc.type, desc.data) 254 255 def coerce(data, egdata): 256 """Coerce a python object to another type using the AE coercers""" 257 pdata = pack(data) 258 pegdata = pack(egdata) 259 pdata = pdata.AECoerceDesc(pegdata.type) 260 return unpack(pdata) 261 262 # 263 # Helper routines for unpack 264 # 265 def mktargetid(data): 266 sessionID = getlong(data[:4]) 267 name = mkppcportrec(data[4:4+72]) 268 location = mklocationnamerec(data[76:76+36]) 269 rcvrName = mkppcportrec(data[112:112+72]) 270 return sessionID, name, location, rcvrName 271 272 def mkppcportrec(rec): 273 namescript = getword(rec[:2]) 274 name = getpstr(rec[2:2+33]) 275 portkind = getword(rec[36:38]) 276 if portkind == 1: 277 ctor = rec[38:42] 278 type = rec[42:46] 279 identity = (ctor, type) 280 else: 281 identity = getpstr(rec[38:38+33]) 282 return namescript, name, portkind, identity 283 284 def mklocationnamerec(rec): 285 kind = getword(rec[:2]) 286 stuff = rec[2:] 287 if kind == 0: stuff = None 288 if kind == 2: stuff = getpstr(stuff) 289 return kind, stuff 290 291 def mkunknown(type, data): 292 return aetypes.Unknown(type, data) 293 294 def getpstr(s): 295 return s[1:1+ord(s[0])] 296 297 def getlong(s): 298 return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3]) 299 300 def getword(s): 301 return (ord(s[0])<<8) | (ord(s[1])<<0) 302 303 def mkkeyword(keyword): 304 return aetypes.Keyword(keyword) 305 306 def mkrange(dict): 307 return aetypes.Range(dict['star'], dict['stop']) 308 309 def mkcomparison(dict): 310 return aetypes.Comparison(dict['obj1'], dict['relo'].enum, dict['obj2']) 311 312 def mklogical(dict): 313 return aetypes.Logical(dict['logc'], dict['term']) 314 315 def mkstyledtext(dict): 316 return aetypes.StyledText(dict['ksty'], dict['ktxt']) 317 318 def mkaetext(dict): 319 return aetypes.AEText(dict[keyAEScriptTag], dict[keyAEStyles], dict[keyAEText]) 320 321 def mkinsertionloc(dict): 322 return aetypes.InsertionLoc(dict[keyAEObject], dict[keyAEPosition]) 323 324 def mkobject(dict): 325 want = dict['want'].type 326 form = dict['form'].enum 327 seld = dict['seld'] 328 fr = dict['from'] 329 if form in ('name', 'indx', 'rang', 'test'): 330 if want == 'text': return aetypes.Text(seld, fr) 331 if want == 'cha ': return aetypes.Character(seld, fr) 332 if want == 'cwor': return aetypes.Word(seld, fr) 333 if want == 'clin': return aetypes.Line(seld, fr) 334 if want == 'cpar': return aetypes.Paragraph(seld, fr) 335 if want == 'cwin': return aetypes.Window(seld, fr) 336 if want == 'docu': return aetypes.Document(seld, fr) 337 if want == 'file': return aetypes.File(seld, fr) 338 if want == 'cins': return aetypes.InsertionPoint(seld, fr) 339 if want == 'prop' and form == 'prop' and aetypes.IsType(seld): 340 return aetypes.Property(seld.type, fr) 341 return aetypes.ObjectSpecifier(want, form, seld, fr) 342 343 # Note by Jack: I'm not 100% sure of the following code. This was 344 # provided by Donovan Preston, but I wonder whether the assignment 345 # to __class__ is safe. Moreover, shouldn't there be a better 346 # initializer for the classes in the suites? 347 def mkobjectfrommodule(dict, modulename): 348 if type(dict['want']) == types.ClassType and issubclass(dict['want'], ObjectSpecifier): 349 # The type has already been converted to Python. Convert back:-( 350 classtype = dict['want'] 351 dict['want'] = aetypes.mktype(classtype.want) 352 want = dict['want'].type 353 module = __import__(modulename) 354 codenamemapper = module._classdeclarations 355 classtype = codenamemapper.get(want, None) 356 newobj = mkobject(dict) 357 if classtype: 358 assert issubclass(classtype, ObjectSpecifier) 359 newobj.__class__ = classtype 360 return newobj 361 362 def mktype(typecode, modulename=None): 363 if modulename: 364 module = __import__(modulename) 365 codenamemapper = module._classdeclarations 366 classtype = codenamemapper.get(typecode, None) 367 if classtype: 368 return classtype 369 return aetypes.mktype(typecode) 370
