1 files changed, 571 insertions, 0 deletions
diff --git a/lib/python2.7/plat-mac/aetypes.py b/lib/python2.7/plat-mac/aetypes.py
new file mode 100644
index 0000000..f333156
--- /dev/null
+++ b/lib/python2.7/plat-mac/aetypes.py
@@ -0,0 +1,571 @@
+"""aetypes - Python objects representing various AE types."""
+
+from warnings import warnpy3k
+warnpy3k("In 3.x, the aetypes module is removed.", stacklevel=2)
+
+from Carbon.AppleEvents import *
+import struct
+from types import *
+import string
+
+#
+# convoluted, since there are cyclic dependencies between this file and
+# aetools_convert.
+#
+def pack(*args, **kwargs):
+    from aepack import pack
+    return pack( *args, **kwargs)
+
+def nice(s):
+    """'nice' representation of an object"""
+    if type(s) is StringType: return repr(s)
+    else: return str(s)
+
+class Unknown:
+    """An uninterpreted AE object"""
+
+    def __init__(self, type, data):
+        self.type = type
+        self.data = data
+
+    def __repr__(self):
+        return "Unknown(%r, %r)" % (self.type, self.data)
+
+    def __aepack__(self):
+        return pack(self.data, self.type)
+
+class Enum:
+    """An AE enumeration value"""
+
+    def __init__(self, enum):
+        self.enum = "%-4.4s" % str(enum)
+
+    def __repr__(self):
+        return "Enum(%r)" % (self.enum,)
+
+    def __str__(self):
+        return string.strip(self.enum)
+
+    def __aepack__(self):
+        return pack(self.enum, typeEnumeration)
+
+def IsEnum(x):
+    return isinstance(x, Enum)
+
+def mkenum(enum):
+    if IsEnum(enum): return enum
+    return Enum(enum)
+
+# Jack changed the way this is done
+class InsertionLoc:
+    def __init__(self, of, pos):
+        self.of = of
+        self.pos = pos
+
+    def __repr__(self):
+        return "InsertionLoc(%r, %r)" % (self.of, self.pos)
+
+    def __aepack__(self):
+        rec = {'kobj': self.of, 'kpos': self.pos}
+        return pack(rec, forcetype='insl')
+
+# Convenience functions for dsp:
+def beginning(of):
+    return InsertionLoc(of, Enum('bgng'))
+
+def end(of):
+    return InsertionLoc(of, Enum('end '))
+
+class Boolean:
+    """An AE boolean value"""
+
+    def __init__(self, bool):
+        self.bool = (not not bool)
+
+    def __repr__(self):
+        return "Boolean(%r)" % (self.bool,)
+
+    def __str__(self):
+        if self.bool:
+            return "True"
+        else:
+            return "False"
+
+    def __aepack__(self):
+        return pack(struct.pack('b', self.bool), 'bool')
+
+def IsBoolean(x):
+    return isinstance(x, Boolean)
+
+def mkboolean(bool):
+    if IsBoolean(bool): return bool
+    return Boolean(bool)
+
+class Type:
+    """An AE 4-char typename object"""
+
+    def __init__(self, type):
+        self.type = "%-4.4s" % str(type)
+
+    def __repr__(self):
+        return "Type(%r)" % (self.type,)
+
+    def __str__(self):
+        return string.strip(self.type)
+
+    def __aepack__(self):
+        return pack(self.type, typeType)
+
+def IsType(x):
+    return isinstance(x, Type)
+
+def mktype(type):
+    if IsType(type): return type
+    return Type(type)
+
+
+class Keyword:
+    """An AE 4-char keyword object"""
+
+    def __init__(self, keyword):
+        self.keyword = "%-4.4s" % str(keyword)
+
+    def __repr__(self):
+        return "Keyword(%r)" % repr(self.keyword)
+
+    def __str__(self):
+        return string.strip(self.keyword)
+
+    def __aepack__(self):
+        return pack(self.keyword, typeKeyword)
+
+def IsKeyword(x):
+    return isinstance(x, Keyword)
+
+class Range:
+    """An AE range object"""
+
+    def __init__(self, start, stop):
+        self.start = start
+        self.stop = stop
+
+    def __repr__(self):
+        return "Range(%r, %r)" % (self.start, self.stop)
+
+    def __str__(self):
+        return "%s thru %s" % (nice(self.start), nice(self.stop))
+
+    def __aepack__(self):
+        return pack({'star': self.start, 'stop': self.stop}, 'rang')
+
+def IsRange(x):
+    return isinstance(x, Range)
+
+class Comparison:
+    """An AE Comparison"""
+
+    def __init__(self, obj1, relo, obj2):
+        self.obj1 = obj1
+        self.relo = "%-4.4s" % str(relo)
+        self.obj2 = obj2
+
+    def __repr__(self):
+        return "Comparison(%r, %r, %r)" % (self.obj1, self.relo, self.obj2)
+
+    def __str__(self):
+        return "%s %s %s" % (nice(self.obj1), string.strip(self.relo), nice(self.obj2))
+
+    def __aepack__(self):
+        return pack({'obj1': self.obj1,
+                 'relo': mkenum(self.relo),
+                 'obj2': self.obj2},
+                'cmpd')
+
+def IsComparison(x):
+    return isinstance(x, Comparison)
+
+class NComparison(Comparison):
+    # The class attribute 'relo' must be set in a subclass
+
+    def __init__(self, obj1, obj2):
+        Comparison.__init__(obj1, self.relo, obj2)
+
+class Ordinal:
+    """An AE Ordinal"""
+
+    def __init__(self, abso):
+#       self.obj1 = obj1
+        self.abso = "%-4.4s" % str(abso)
+
+    def __repr__(self):
+        return "Ordinal(%r)" % (self.abso,)
+
+    def __str__(self):
+        return "%s" % (string.strip(self.abso))
+
+    def __aepack__(self):
+        return pack(self.abso, 'abso')
+
+def IsOrdinal(x):
+    return isinstance(x, Ordinal)
+
+class NOrdinal(Ordinal):
+    # The class attribute 'abso' must be set in a subclass
+
+    def __init__(self):
+        Ordinal.__init__(self, self.abso)
+
+class Logical:
+    """An AE logical expression object"""
+
+    def __init__(self, logc, term):
+        self.logc = "%-4.4s" % str(logc)
+        self.term = term
+
+    def __repr__(self):
+        return "Logical(%r, %r)" % (self.logc, self.term)
+
+    def __str__(self):
+        if type(self.term) == ListType and len(self.term) == 2:
+            return "%s %s %s" % (nice(self.term[0]),
+                                 string.strip(self.logc),
+                                 nice(self.term[1]))
+        else:
+            return "%s(%s)" % (string.strip(self.logc), nice(self.term))
+
+    def __aepack__(self):
+        return pack({'logc': mkenum(self.logc), 'term': self.term}, 'logi')
+
+def IsLogical(x):
+    return isinstance(x, Logical)
+
+class StyledText:
+    """An AE object respresenting text in a certain style"""
+
+    def __init__(self, style, text):
+        self.style = style
+        self.text = text
+
+    def __repr__(self):
+        return "StyledText(%r, %r)" % (self.style, self.text)
+
+    def __str__(self):
+        return self.text
+
+    def __aepack__(self):
+        return pack({'ksty': self.style, 'ktxt': self.text}, 'STXT')
+
+def IsStyledText(x):
+    return isinstance(x, StyledText)
+
+class AEText:
+    """An AE text object with style, script and language specified"""
+
+    def __init__(self, script, style, text):
+        self.script = script
+        self.style = style
+        self.text = text
+
+    def __repr__(self):
+        return "AEText(%r, %r, %r)" % (self.script, self.style, self.text)
+
+    def __str__(self):
+        return self.text
+
+    def __aepack__(self):
+        return pack({keyAEScriptTag: self.script, keyAEStyles: self.style,
+                 keyAEText: self.text}, typeAEText)
+
+def IsAEText(x):
+    return isinstance(x, AEText)
+
+class IntlText:
+    """A text object with script and language specified"""
+
+    def __init__(self, script, language, text):
+        self.script = script
+        self.language = language
+        self.text = text
+
+    def __repr__(self):
+        return "IntlText(%r, %r, %r)" % (self.script, self.language, self.text)
+
+    def __str__(self):
+        return self.text
+
+    def __aepack__(self):
+        return pack(struct.pack('hh', self.script, self.language)+self.text,
+            typeIntlText)
+
+def IsIntlText(x):
+    return isinstance(x, IntlText)
+
+class IntlWritingCode:
+    """An object representing script and language"""
+
+    def __init__(self, script, language):
+        self.script = script
+        self.language = language
+
+    def __repr__(self):
+        return "IntlWritingCode(%r, %r)" % (self.script, self.language)
+
+    def __str__(self):
+        return "script system %d, language %d"%(self.script, self.language)
+
+    def __aepack__(self):
+        return pack(struct.pack('hh', self.script, self.language),
+            typeIntlWritingCode)
+
+def IsIntlWritingCode(x):
+    return isinstance(x, IntlWritingCode)
+
+class QDPoint:
+    """A point"""
+
+    def __init__(self, v, h):
+        self.v = v
+        self.h = h
+
+    def __repr__(self):
+        return "QDPoint(%r, %r)" % (self.v, self.h)
+
+    def __str__(self):
+        return "(%d, %d)"%(self.v, self.h)
+
+    def __aepack__(self):
+        return pack(struct.pack('hh', self.v, self.h),
+            typeQDPoint)
+
+def IsQDPoint(x):
+    return isinstance(x, QDPoint)
+
+class QDRectangle:
+    """A rectangle"""
+
+    def __init__(self, v0, h0, v1, h1):
+        self.v0 = v0
+        self.h0 = h0
+        self.v1 = v1
+        self.h1 = h1
+
+    def __repr__(self):
+        return "QDRectangle(%r, %r, %r, %r)" % (self.v0, self.h0, self.v1, self.h1)
+
+    def __str__(self):
+        return "(%d, %d)-(%d, %d)"%(self.v0, self.h0, self.v1, self.h1)
+
+    def __aepack__(self):
+        return pack(struct.pack('hhhh', self.v0, self.h0, self.v1, self.h1),
+            typeQDRectangle)
+
+def IsQDRectangle(x):
+    return isinstance(x, QDRectangle)
+
+class RGBColor:
+    """An RGB color"""
+
+    def __init__(self, r, g, b):
+        self.r = r
+        self.g = g
+        self.b = b
+
+    def __repr__(self):
+        return "RGBColor(%r, %r, %r)" % (self.r, self.g, self.b)
+
+    def __str__(self):
+        return "0x%x red, 0x%x green, 0x%x blue"% (self.r, self.g, self.b)
+
+    def __aepack__(self):
+        return pack(struct.pack('hhh', self.r, self.g, self.b),
+            typeRGBColor)
+
+def IsRGBColor(x):
+    return isinstance(x, RGBColor)
+
+class ObjectSpecifier:
+
+    """A class for constructing and manipulation AE object specifiers in python.
+
+    An object specifier is actually a record with four fields:
+
+    key type    description
+    --- ----    -----------
+
+    'want'  type    4-char class code of thing we want,
+            e.g. word, paragraph or property
+
+    'form'  enum    how we specify which 'want' thing(s) we want,
+            e.g. by index, by range, by name, or by property specifier
+
+    'seld'  any which thing(s) we want,
+            e.g. its index, its name, or its property specifier
+
+    'from'  object  the object in which it is contained,
+            or null, meaning look for it in the application
+
+    Note that we don't call this class plain "Object", since that name
+    is likely to be used by the application.
+    """
+
+    def __init__(self, want, form, seld, fr = None):
+        self.want = want
+        self.form = form
+        self.seld = seld
+        self.fr = fr
+
+    def __repr__(self):
+        s = "ObjectSpecifier(%r, %r, %r" % (self.want, self.form, self.seld)
+        if self.fr:
+            s = s + ", %r)" % (self.fr,)
+        else:
+            s = s + ")"
+        return s
+
+    def __aepack__(self):
+        return pack({'want': mktype(self.want),
+                 'form': mkenum(self.form),
+                 'seld': self.seld,
+                 'from': self.fr},
+                'obj ')
+
+def IsObjectSpecifier(x):
+    return isinstance(x, ObjectSpecifier)
+
+
+# Backwards compatibility, sigh...
+class Property(ObjectSpecifier):
+
+    def __init__(self, which, fr = None, want='prop'):
+        ObjectSpecifier.__init__(self, want, 'prop', mktype(which), fr)
+
+    def __repr__(self):
+        if self.fr:
+            return "Property(%r, %r)" % (self.seld.type, self.fr)
+        else:
+            return "Property(%r)" % (self.seld.type,)
+
+    def __str__(self):
+        if self.fr:
+            return "Property %s of %s" % (str(self.seld), str(self.fr))
+        else:
+            return "Property %s" % str(self.seld)
+
+
+class NProperty(ObjectSpecifier):
+    # Subclasses *must* self baseclass attributes:
+    # want is the type of this property
+    # which is the property name of this property
+
+    def __init__(self, fr = None):
+        #try:
+        #   dummy = self.want
+        #except:
+        #   self.want = 'prop'
+        self.want = 'prop'
+        ObjectSpecifier.__init__(self, self.want, 'prop',
+                    mktype(self.which), fr)
+
+    def __repr__(self):
+        rv = "Property(%r" % (self.seld.type,)
+        if self.fr:
+            rv = rv + ", fr=%r" % (self.fr,)
+        if self.want != 'prop':
+            rv = rv + ", want=%r" % (self.want,)
+        return rv + ")"
+
+    def __str__(self):
+        if self.fr:
+            return "Property %s of %s" % (str(self.seld), str(self.fr))
+        else:
+            return "Property %s" % str(self.seld)
+
+
+class SelectableItem(ObjectSpecifier):
+
+    def __init__(self, want, seld, fr = None):
+        t = type(seld)
+        if t == StringType:
+            form = 'name'
+        elif IsRange(seld):
+            form = 'rang'
+        elif IsComparison(seld) or IsLogical(seld):
+            form = 'test'
+        elif t == TupleType:
+            # Breakout: specify both form and seld in a tuple
+            # (if you want ID or rele or somesuch)
+            form, seld = seld
+        else:
+            form = 'indx'
+        ObjectSpecifier.__init__(self, want, form, seld, fr)
+
+
+class ComponentItem(SelectableItem):
+    # Derived classes *must* set the *class attribute* 'want' to some constant
+    # Also, dictionaries _propdict and _elemdict must be set to map property
+    # and element names to the correct classes
+
+    _propdict = {}
+    _elemdict = {}
+    def __init__(self, which, fr = None):
+        SelectableItem.__init__(self, self.want, which, fr)
+
+    def __repr__(self):
+        if not self.fr:
+            return "%s(%r)" % (self.__class__.__name__, self.seld)
+        return "%s(%r, %r)" % (self.__class__.__name__, self.seld, self.fr)
+
+    def __str__(self):
+        seld = self.seld
+        if type(seld) == StringType:
+            ss = repr(seld)
+        elif IsRange(seld):
+            start, stop = seld.start, seld.stop
+            if type(start) == InstanceType == type(stop) and \
+               start.__class__ == self.__class__ == stop.__class__:
+                ss = str(start.seld) + " thru " + str(stop.seld)
+            else:
+                ss = str(seld)
+        else:
+            ss = str(seld)
+        s = "%s %s" % (self.__class__.__name__, ss)
+        if self.fr: s = s + " of %s" % str(self.fr)
+        return s
+
+    def __getattr__(self, name):
+        if name in self._elemdict:
+            cls = self._elemdict[name]
+            return DelayedComponentItem(cls, self)
+        if name in self._propdict:
+            cls = self._propdict[name]
+            return cls(self)
+        raise AttributeError, name
+
+
+class DelayedComponentItem:
+    def __init__(self, compclass, fr):
+        self.compclass = compclass
+        self.fr = fr
+
+    def __call__(self, which):
+        return self.compclass(which, self.fr)
+
+    def __repr__(self):
+        return "%s(???, %r)" % (self.__class__.__name__, self.fr)
+
+    def __str__(self):
+        return "selector for element %s of %s"%(self.__class__.__name__, str(self.fr))
+
+template = """
+class %s(ComponentItem): want = '%s'
+"""
+
+exec template % ("Text", 'text')
+exec template % ("Character", 'cha ')
+exec template % ("Word", 'cwor')
+exec template % ("Line", 'clin')
+exec template % ("paragraph", 'cpar')
+exec template % ("Window", 'cwin')
+exec template % ("Document", 'docu')
+exec template % ("File", 'file')
+exec template % ("InsertionPoint", 'cins')