- Added classes to support class/property generation by gensuitemodule

- Fixed Property class: selector is a 'type', not an 'enum'

diff --git a/Mac/Lib/toolbox/aepack.py b/Mac/Lib/toolbox/aepack.py
index 8c9def73c6007da5f50095976311604a60af5ebc..9302a548659fa7445d28f5705e49007f24dfedba 100644 (file)
--- a/Mac/Lib/toolbox/aepack.py
+++ b/Mac/Lib/toolbox/aepack.py
@@ -117,6 +117,7 @@ def unpack(desc):
        
        if unpacker_coercions.has_key(t):
                desc = desc.AECoerceDesc(unpacker_coercions[t])
+               t = desc.type # This is a guess by Jack....
        
        if t == typeAEList:
                l = []

diff --git a/Mac/Lib/toolbox/aetools.py b/Mac/Lib/toolbox/aetools.py
index 41b7f2497084680d500b7429f158fa967c083608..21a42371f3e3450dfa7ef9256d4b2a07212660b7 100644 (file)
--- a/Mac/Lib/toolbox/aetools.py
+++ b/Mac/Lib/toolbox/aetools.py
@@ -107,14 +107,17 @@ def enumsubst(arguments, key, edict):
 def decodeerror(arguments):
        """Create the 'best' argument for a raise MacOS.Error"""
        errn = arguments['errn']
-       errarg = (errn, )
+       err_a1 = errn
        if arguments.has_key('errs'):
-               errarg = errarg + (arguments['errs'],)
+               err_a2 = arguments['errs']
+       else:
+               err_a2 = MacOS.GetErrorString(errn)
        if arguments.has_key('erob'):
-               errarg = errarg + (arguments['erob'],)
-       if len(errarg) == 1:
-               errarg = errarg + ('Server returned error code %d'%errn, )
-       return errarg
+               err_a3 = arguments['erob']
+       else:
+               err_a3 = None
+       
+       return (err_a1, err_a2, err_a3)
 
 class TalkTo:
        """An AE connection to an application"""
@@ -178,8 +181,8 @@ class TalkTo:
                """Send 'activate' command"""
                self.send('misc', 'actv')
 
-       def get(self, _object, _attributes={}):
-               """get: get data from an object
+       def _get(self, _object, as=None, _attributes={}):
+               """_get: get data from an object
                Required argument: the object
                Keyword argument _attributes: AppleEvent attribute dictionary
                Returns: the data
@@ -188,7 +191,8 @@ class TalkTo:
                _subcode = 'getd'
 
                _arguments = {'----':_object}
-
+               if as:
+                       _arguments['rtyp'] = mktype(as)
 
                _reply, _arguments, _attributes = self.send(_code, _subcode,
                                _arguments, _attributes)

diff --git a/Mac/Lib/toolbox/aetypes.py b/Mac/Lib/toolbox/aetypes.py
index e0a466f781eab6d3bb006f734cbef4088c9b5494..3dc0d0e2035b9a8b0f7fa1870fba030dd17cc13c 100644 (file)
--- a/Mac/Lib/toolbox/aetypes.py
+++ b/Mac/Lib/toolbox/aetypes.py
@@ -71,6 +71,31 @@ def mkenum(enum):
        if IsEnum(enum): return enum
        return Enum(enum)
 
+class Boolean:
+       """An AE boolean value"""
+       
+       def __init__(self, bool):
+               self.bool = (not not bool)
+       
+       def __repr__(self):
+               return "Boolean(%s)" % `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"""
        
@@ -153,6 +178,12 @@ class Comparison:
 
 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 Logical:
        """An AE logical expression object"""
@@ -332,10 +363,10 @@ class ObjectSpecifier:
        key     type    description
        ---     ----    -----------
        
-       'want'  type    what kind of thing we want,
+       'want'  type    4-char class code of thing we want,
                        e.g. word, paragraph or property
        
-       'form'  enum    how we specify the thing(s) we want,
+       '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,
@@ -369,21 +400,50 @@ class ObjectSpecifier:
                             'from': self.fr},
                            'obj ')
 
-
 def IsObjectSpecifier(x):
        return IsInstance(x, ObjectSpecifier)
 
 
+# Backwards compatability, sigh...
 class Property(ObjectSpecifier):
 
-       def __init__(self, which, fr = None):
-               ObjectSpecifier.__init__(self, 'prop', 'prop', mkenum(which), fr)
+       def __init__(self, which, fr = None, want='prop'):
+               ObjectSpecifier.__init__(self, want, 'prop', mktype(which), fr)
 
        def __repr__(self):
                if self.fr:
-                       return "Property(%s, %s)" % (`self.seld.enum`, `self.fr`)
+                       return "Property(%s, %s)" % (`self.seld.type`, `self.fr`)
                else:
-                       return "Property(%s)" % `self.seld.enum`
+                       return "Property(%s)" % `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(%s"%`self.seld.type`
+               if self.fr:
+                       rv = rv + ", fr=%s" % `self.fr`
+               if self.want != 'prop':
+                       rv = rv + ", want=%s" % `self.want`
+               return rv + ")"
        
        def __str__(self):
                if self.fr:
@@ -402,6 +462,10 @@ class SelectableItem(ObjectSpecifier):
                        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)
@@ -409,6 +473,8 @@ class SelectableItem(ObjectSpecifier):
 
 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
        
        def __init__(self, which, fr = None):
                SelectableItem.__init__(self, self.want, which, fr)
@@ -434,7 +500,30 @@ class ComponentItem(SelectableItem):
                s = "%s %s" % (self.__class__.__name__, ss)
                if self.fr: s = s + " of %s" % str(self.fr)
                return s
-
+               
+       def __getattr__(self, name):
+               if self._elemdict.has_key(name):
+                       cls = self._elemdict[name]
+                       return DelayedComponentItem(cls, self)
+               if self._propdict.has_key(name):
+                       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(???, %s)" % (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'