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 FSSType = Carbon.File.FSSpecType

    62 FSRefType = Carbon.File.FSRefType

    63 AliasType = Carbon.File.AliasType

    64 

    65 def packkey(ae, key, value):

    66     if hasattr(key, 'which'):

    67         keystr = key.which

    68     elif hasattr(key, 'want'):

    69         keystr = key.want

    70     else:

    71         keystr = key

    72     ae.AEPutParamDesc(keystr, pack(value))

    73 

    74 def pack(x, forcetype = None):

    75     """Pack a python object into an AE descriptor"""

    76 

    77     if forcetype:

    78         if type(x) is StringType:

    79             return AE.AECreateDesc(forcetype, x)

    80         else:

    81             return pack(x).AECoerceDesc(forcetype)

    82 

    83     if x is None:

    84         return AE.AECreateDesc('null', '')

    85 

    86     if isinstance(x, AEDescType):

    87         return x

    88     if isinstance(x, FSSType):

    89         return AE.AECreateDesc('fss ', x.data)

    90     if isinstance(x, FSRefType):

    91         return AE.AECreateDesc('fsrf', x.data)

    92     if isinstance(x, AliasType):

    93         return AE.AECreateDesc('alis', x.data)

    94     if isinstance(x, IntType):

    95         return AE.AECreateDesc('long', struct.pack('l', x))

    96     if isinstance(x, FloatType):

    97         return AE.AECreateDesc('doub', struct.pack('d', x))

    98     if isinstance(x, StringType):

    99         return AE.AECreateDesc('TEXT', x)

   100     if isinstance(x, UnicodeType):

   101         data = x.encode('utf16')

   102         if data[:2] == '\xfe\xff':

   103             data = data[2:]

   104         return AE.AECreateDesc('utxt', data)

   105     if isinstance(x, ListType):

   106         list = AE.AECreateList('', 0)

   107         for item in x:

   108             list.AEPutDesc(0, pack(item))

   109         return list

   110     if isinstance(x, DictionaryType):

   111         record = AE.AECreateList('', 1)

   112         for key, value in x.items():

   113             packkey(record, key, value)

   114             #record.AEPutParamDesc(key, pack(value))

   115         return record

   116     if type(x) == types.ClassType and issubclass(x, ObjectSpecifier):

   117         # Note: we are getting a class object here, not an instance

   118         return AE.AECreateDesc('type', x.want)

   119     if hasattr(x, '__aepack__'):

   120         return x.__aepack__()

   121     if hasattr(x, 'which'):

   122         return AE.AECreateDesc('TEXT', x.which)

   123     if hasattr(x, 'want'):

   124         return AE.AECreateDesc('TEXT', x.want)

   125     return AE.AECreateDesc('TEXT', repr(x)) # Copout

   126 

   127 def unpack(desc, formodulename=""):

   128     """Unpack an AE descriptor to a python object"""

   129     t = desc.type

   130 

   131     if unpacker_coercions.has_key(t):

   132         desc = desc.AECoerceDesc(unpacker_coercions[t])

   133         t = desc.type # This is a guess by Jack....

   134 

   135     if t == typeAEList:

   136         l = []

   137         for i in range(desc.AECountItems()):

   138             keyword, item = desc.AEGetNthDesc(i+1, '****')

   139             l.append(unpack(item, formodulename))

   140         return l

   141     if t == typeAERecord:

   142         d = {}

   143         for i in range(desc.AECountItems()):

   144             keyword, item = desc.AEGetNthDesc(i+1, '****')

   145             d[keyword] = unpack(item, formodulename)

   146         return d

   147     if t == typeAEText:

   148         record = desc.AECoerceDesc('reco')

   149         return mkaetext(unpack(record, formodulename))

   150     if t == typeAlias:

   151         return Carbon.File.Alias(rawdata=desc.data)

   152     # typeAppleEvent returned as unknown

   153     if t == typeBoolean:

   154         return struct.unpack('b', desc.data)[0]

   155     if t == typeChar:

   156         return desc.data

   157     if t == typeUnicodeText:

   158         return unicode(desc.data, 'utf16')

   159     # typeColorTable coerced to typeAEList

   160     # typeComp coerced to extended

   161     # typeData returned as unknown

   162     # typeDrawingArea coerced to typeAERecord

   163     if t == typeEnumeration:

   164         return mkenum(desc.data)

   165     # typeEPS returned as unknown

   166     if t == typeFalse:

   167         return 0

   168     if t == typeFloat:

   169         data = desc.data

   170         return struct.unpack('d', data)[0]

   171     if t == typeFSS:

   172         return Carbon.File.FSSpec(rawdata=desc.data)

   173     if t == typeFSRef:

   174         return Carbon.File.FSRef(rawdata=desc.data)

   175     if t == typeInsertionLoc:

   176         record = desc.AECoerceDesc('reco')

   177         return mkinsertionloc(unpack(record, formodulename))

   178     # typeInteger equal to typeLongInteger

   179     if t == typeIntlText:

   180         script, language = struct.unpack('hh', desc.data[:4])

   181         return aetypes.IntlText(script, language, desc.data[4:])

   182     if t == typeIntlWritingCode:

   183         script, language = struct.unpack('hh', desc.data)

   184         return aetypes.IntlWritingCode(script, language)

   185     if t == typeKeyword:

   186         return mkkeyword(desc.data)

   187     if t == typeLongInteger:

   188         return struct.unpack('l', desc.data)[0]

   189     if t == typeLongDateTime:

   190         a, b = struct.unpack('lL', desc.data)

   191         return (long(a) << 32) + b

   192     if t == typeNull:

   193         return None

   194     if t == typeMagnitude:

   195         v = struct.unpack('l', desc.data)

   196         if v < 0:

   197             v = 0x100000000L + v

   198         return v

   199     if t == typeObjectSpecifier:

   200         record = desc.AECoerceDesc('reco')

   201         # If we have been told the name of the module we are unpacking aedescs for,

   202         # we can attempt to create the right type of python object from that module.

   203         if formodulename:

   204             return mkobjectfrommodule(unpack(record, formodulename), formodulename)

   205         return mkobject(unpack(record, formodulename))

   206     # typePict returned as unknown

   207     # typePixelMap coerced to typeAERecord

   208     # typePixelMapMinus returned as unknown

   209     # typeProcessSerialNumber returned as unknown

   210     if t == typeQDPoint:

   211         v, h = struct.unpack('hh', desc.data)

   212         return aetypes.QDPoint(v, h)

   213     if t == typeQDRectangle:

   214         v0, h0, v1, h1 = struct.unpack('hhhh', desc.data)

   215         return aetypes.QDRectangle(v0, h0, v1, h1)

   216     if t == typeRGBColor:

   217         r, g, b = struct.unpack('hhh', desc.data)

   218         return aetypes.RGBColor(r, g, b)

   219     # typeRotation coerced to typeAERecord

   220     # typeScrapStyles returned as unknown

   221     # typeSessionID returned as unknown

   222     if t == typeShortFloat:

   223         return struct.unpack('f', desc.data)[0]

   224     if t == typeShortInteger:

   225         return struct.unpack('h', desc.data)[0]

   226     # typeSMFloat identical to typeShortFloat

   227     # typeSMInt indetical to typeShortInt

   228     # typeStyledText coerced to typeAERecord

   229     if t == typeTargetID:

   230         return mktargetid(desc.data)

   231     # typeTextStyles coerced to typeAERecord

   232     # typeTIFF returned as unknown

   233     if t == typeTrue:

   234         return 1

   235     if t == typeType:

   236         return mktype(desc.data, formodulename)

   237     #

   238     # The following are special

   239     #

   240     if t == 'rang':

   241         record = desc.AECoerceDesc('reco')

   242         return mkrange(unpack(record, formodulename))

   243     if t == 'cmpd':

   244         record = desc.AECoerceDesc('reco')

   245         return mkcomparison(unpack(record, formodulename))

   246     if t == 'logi':

   247         record = desc.AECoerceDesc('reco')

   248         return mklogical(unpack(record, formodulename))

   249     return mkunknown(desc.type, desc.data)

   250 

   251 def coerce(data, egdata):

   252     """Coerce a python object to another type using the AE coercers"""

   253     pdata = pack(data)

   254     pegdata = pack(egdata)

   255     pdata = pdata.AECoerceDesc(pegdata.type)

   256     return unpack(pdata)

   257 

   258 #

   259 # Helper routines for unpack

   260 #

   261 def mktargetid(data):

   262     sessionID = getlong(data[:4])

   263     name = mkppcportrec(data[4:4+72])

   264     location = mklocationnamerec(data[76:76+36])

   265     rcvrName = mkppcportrec(data[112:112+72])

   266     return sessionID, name, location, rcvrName

   267 

   268 def mkppcportrec(rec):

   269     namescript = getword(rec[:2])

   270     name = getpstr(rec[2:2+33])

   271     portkind = getword(rec[36:38])

   272     if portkind == 1:

   273         ctor = rec[38:42]

   274         type = rec[42:46]

   275         identity = (ctor, type)

   276     else:

   277         identity = getpstr(rec[38:38+33])

   278     return namescript, name, portkind, identity

   279 

   280 def mklocationnamerec(rec):

   281     kind = getword(rec[:2])

   282     stuff = rec[2:]

   283     if kind == 0: stuff = None

   284     if kind == 2: stuff = getpstr(stuff)

   285     return kind, stuff

   286 

   287 def mkunknown(type, data):

   288     return aetypes.Unknown(type, data)

   289 

   290 def getpstr(s):

   291     return s[1:1+ord(s[0])]

   292 

   293 def getlong(s):

   294     return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])

   295 

   296 def getword(s):

   297     return (ord(s[0])<<8) | (ord(s[1])<<0)

   298 

   299 def mkkeyword(keyword):

   300     return aetypes.Keyword(keyword)

   301 

   302 def mkrange(dict):

   303     return aetypes.Range(dict['star'], dict['stop'])

   304 

   305 def mkcomparison(dict):

   306     return aetypes.Comparison(dict['obj1'], dict['relo'].enum, dict['obj2'])

   307 

   308 def mklogical(dict):

   309     return aetypes.Logical(dict['logc'], dict['term'])

   310 

   311 def mkstyledtext(dict):

   312     return aetypes.StyledText(dict['ksty'], dict['ktxt'])

   313 

   314 def mkaetext(dict):

   315     return aetypes.AEText(dict[keyAEScriptTag], dict[keyAEStyles], dict[keyAEText])

   316 

   317 def mkinsertionloc(dict):

   318     return aetypes.InsertionLoc(dict[keyAEObject], dict[keyAEPosition])

   319 

   320 def mkobject(dict):

   321     want = dict['want'].type

   322     form = dict['form'].enum

   323     seld = dict['seld']

   324     fr   = dict['from']

   325     if form in ('name', 'indx', 'rang', 'test'):

   326         if want == 'text': return aetypes.Text(seld, fr)

   327         if want == 'cha ': return aetypes.Character(seld, fr)

   328         if want == 'cwor': return aetypes.Word(seld, fr)

   329         if want == 'clin': return aetypes.Line(seld, fr)

   330         if want == 'cpar': return aetypes.Paragraph(seld, fr)

   331         if want == 'cwin': return aetypes.Window(seld, fr)

   332         if want == 'docu': return aetypes.Document(seld, fr)

   333         if want == 'file': return aetypes.File(seld, fr)

   334         if want == 'cins': return aetypes.InsertionPoint(seld, fr)

   335     if want == 'prop' and form == 'prop' and aetypes.IsType(seld):

   336         return aetypes.Property(seld.type, fr)

   337     return aetypes.ObjectSpecifier(want, form, seld, fr)

   338 

   339 # Note by Jack: I'm not 100% sure of the following code. This was

   340 # provided by Donovan Preston, but I wonder whether the assignment

   341 # to __class__ is safe. Moreover, shouldn't there be a better

   342 # initializer for the classes in the suites?

   343 def mkobjectfrommodule(dict, modulename):

   344     if type(dict['want']) == types.ClassType and issubclass(dict['want'], ObjectSpecifier):

   345         # The type has already been converted to Python. Convert back:-(

   346         classtype = dict['want']

   347         dict['want'] = aetypes.mktype(classtype.want)

   348     want = dict['want'].type

   349     module = __import__(modulename)

   350     codenamemapper = module._classdeclarations

   351     classtype = codenamemapper.get(want, None)

   352     newobj = mkobject(dict)

   353     if classtype:

   354         assert issubclass(classtype, ObjectSpecifier)

   355         newobj.__class__ = classtype

   356     return newobj

   357 

   358 def mktype(typecode, modulename=None):

   359     if modulename:

   360         module = __import__(modulename)

   361         codenamemapper = module._classdeclarations

   362         classtype = codenamemapper.get(typecode, None)

   363         if classtype:

   364             return classtype

   365     return aetypes.mktype(typecode)