Lib/plat-mac/aepack.py

   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 unpacker_coercions.has_key(t):
 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)