Home | History | Annotate | Download | only in Finder 
      1 """Suite Standard Suite: Common terms that most applications should support
      2 Level 1, version 1
      3 
      4 Generated from /System/Library/CoreServices/Finder.app
      5 AETE/AEUT resource version 0/144, language 0, script 0
      6 """
      7 
      8 import aetools
      9 import MacOS
     10 
     11 _code = 'CoRe'
     12 
     13 from StdSuites.Standard_Suite import *
     14 class Standard_Suite_Events(Standard_Suite_Events):
     15 
     16     def close(self, _object, _attributes={}, **_arguments):
     17         """close: Close an object
     18         Required argument: the object to close
     19         Keyword argument _attributes: AppleEvent attribute dictionary
     20         """
     21         _code = 'core'
     22         _subcode = 'clos'
     23 
     24         if _arguments: raise TypeError, 'No optional args expected'
     25         _arguments['----'] = _object
     26 
     27 
     28         _reply, _arguments, _attributes = self.send(_code, _subcode,
     29                 _arguments, _attributes)
     30         if _arguments.get('errn', 0):
     31             raise aetools.Error, aetools.decodeerror(_arguments)
     32         # XXXX Optionally decode result
     33         if _arguments.has_key('----'):
     34             return _arguments['----']
     35 
     36     _argmap_count = {
     37         'each' : 'kocl',
     38     }
     39 
     40     def count(self, _object, _attributes={}, **_arguments):
     41         """count: Return the number of elements of a particular class within an object
     42         Required argument: the object whose elements are to be counted
     43         Keyword argument each: the class of the elements to be counted
     44         Keyword argument _attributes: AppleEvent attribute dictionary
     45         Returns: the number of elements
     46         """
     47         _code = 'core'
     48         _subcode = 'cnte'
     49 
     50         aetools.keysubst(_arguments, self._argmap_count)
     51         _arguments['----'] = _object
     52 
     53 
     54         _reply, _arguments, _attributes = self.send(_code, _subcode,
     55                 _arguments, _attributes)
     56         if _arguments.get('errn', 0):
     57             raise aetools.Error, aetools.decodeerror(_arguments)
     58         # XXXX Optionally decode result
     59         if _arguments.has_key('----'):
     60             return _arguments['----']
     61 
     62     _argmap_data_size = {
     63         'as' : 'rtyp',
     64     }
     65 
     66     def data_size(self, _object, _attributes={}, **_arguments):
     67         """data size: Return the size in bytes of an object
     68         Required argument: the object whose data size is to be returned
     69         Keyword argument as: the data type for which the size is calculated
     70         Keyword argument _attributes: AppleEvent attribute dictionary
     71         Returns: the size of the object in bytes
     72         """
     73         _code = 'core'
     74         _subcode = 'dsiz'
     75 
     76         aetools.keysubst(_arguments, self._argmap_data_size)
     77         _arguments['----'] = _object
     78 
     79 
     80         _reply, _arguments, _attributes = self.send(_code, _subcode,
     81                 _arguments, _attributes)
     82         if _arguments.get('errn', 0):
     83             raise aetools.Error, aetools.decodeerror(_arguments)
     84         # XXXX Optionally decode result
     85         if _arguments.has_key('----'):
     86             return _arguments['----']
     87 
     88     def delete(self, _object, _attributes={}, **_arguments):
     89         """delete: Move an item from its container to the trash
     90         Required argument: the item to delete
     91         Keyword argument _attributes: AppleEvent attribute dictionary
     92         Returns: to the item that was just deleted
     93         """
     94         _code = 'core'
     95         _subcode = 'delo'
     96 
     97         if _arguments: raise TypeError, 'No optional args expected'
     98         _arguments['----'] = _object
     99 
    100 
    101         _reply, _arguments, _attributes = self.send(_code, _subcode,
    102                 _arguments, _attributes)
    103         if _arguments.get('errn', 0):
    104             raise aetools.Error, aetools.decodeerror(_arguments)
    105         # XXXX Optionally decode result
    106         if _arguments.has_key('----'):
    107             return _arguments['----']
    108 
    109     _argmap_duplicate = {
    110         'to' : 'insh',
    111         'replacing' : 'alrp',
    112         'routing_suppressed' : 'rout',
    113     }
    114 
    115     def duplicate(self, _object, _attributes={}, **_arguments):
    116         """duplicate: Duplicate one or more object(s)
    117         Required argument: the object(s) to duplicate
    118         Keyword argument to: the new location for the object(s)
    119         Keyword argument replacing: Specifies whether or not to replace items in the destination that have the same name as items being duplicated
    120         Keyword argument routing_suppressed: Specifies whether or not to autoroute items (default is false). Only applies when copying to the system folder.
    121         Keyword argument _attributes: AppleEvent attribute dictionary
    122         Returns: to the duplicated object(s)
    123         """
    124         _code = 'core'
    125         _subcode = 'clon'
    126 
    127         aetools.keysubst(_arguments, self._argmap_duplicate)
    128         _arguments['----'] = _object
    129 
    130         aetools.enumsubst(_arguments, 'alrp', _Enum_bool)
    131         aetools.enumsubst(_arguments, 'rout', _Enum_bool)
    132 
    133         _reply, _arguments, _attributes = self.send(_code, _subcode,
    134                 _arguments, _attributes)
    135         if _arguments.get('errn', 0):
    136             raise aetools.Error, aetools.decodeerror(_arguments)
    137         # XXXX Optionally decode result
    138         if _arguments.has_key('----'):
    139             return _arguments['----']
    140 
    141     def exists(self, _object, _attributes={}, **_arguments):
    142         """exists: Verify if an object exists
    143         Required argument: the object in question
    144         Keyword argument _attributes: AppleEvent attribute dictionary
    145         Returns: true if it exists, false if not
    146         """
    147         _code = 'core'
    148         _subcode = 'doex'
    149 
    150         if _arguments: raise TypeError, 'No optional args expected'
    151         _arguments['----'] = _object
    152 
    153 
    154         _reply, _arguments, _attributes = self.send(_code, _subcode,
    155                 _arguments, _attributes)
    156         if _arguments.get('errn', 0):
    157             raise aetools.Error, aetools.decodeerror(_arguments)
    158         # XXXX Optionally decode result
    159         if _arguments.has_key('----'):
    160             return _arguments['----']
    161 
    162     _argmap_make = {
    163         'new' : 'kocl',
    164         'at' : 'insh',
    165         'to' : 'to  ',
    166         'with_properties' : 'prdt',
    167     }
    168 
    169     def make(self, _no_object=None, _attributes={}, **_arguments):
    170         """make: Make a new element
    171         Keyword argument new: the class of the new element
    172         Keyword argument at: the location at which to insert the element
    173         Keyword argument to: when creating an alias file, the original item to create an alias to or when creating a file viewer window, the target of the window
    174         Keyword argument with_properties: the initial values for the properties of the element
    175         Keyword argument _attributes: AppleEvent attribute dictionary
    176         Returns: to the new object(s)
    177         """
    178         _code = 'core'
    179         _subcode = 'crel'
    180 
    181         aetools.keysubst(_arguments, self._argmap_make)
    182         if _no_object is not None: raise TypeError, 'No direct arg expected'
    183 
    184 
    185         _reply, _arguments, _attributes = self.send(_code, _subcode,
    186                 _arguments, _attributes)
    187         if _arguments.get('errn', 0):
    188             raise aetools.Error, aetools.decodeerror(_arguments)
    189         # XXXX Optionally decode result
    190         if _arguments.has_key('----'):
    191             return _arguments['----']
    192 
    193     _argmap_move = {
    194         'to' : 'insh',
    195         'replacing' : 'alrp',
    196         'positioned_at' : 'mvpl',
    197         'routing_suppressed' : 'rout',
    198     }
    199 
    200     def move(self, _object, _attributes={}, **_arguments):
    201         """move: Move object(s) to a new location
    202         Required argument: the object(s) to move
    203         Keyword argument to: the new location for the object(s)
    204         Keyword argument replacing: Specifies whether or not to replace items in the destination that have the same name as items being moved
    205         Keyword argument positioned_at: Gives a list (in local window coordinates) of positions for the destination items
    206         Keyword argument routing_suppressed: Specifies whether or not to autoroute items (default is false). Only applies when moving to the system folder.
    207         Keyword argument _attributes: AppleEvent attribute dictionary
    208         Returns: to the object(s) after they have been moved
    209         """
    210         _code = 'core'
    211         _subcode = 'move'
    212 
    213         aetools.keysubst(_arguments, self._argmap_move)
    214         _arguments['----'] = _object
    215 
    216         aetools.enumsubst(_arguments, 'alrp', _Enum_bool)
    217         aetools.enumsubst(_arguments, 'mvpl', _Enum_list)
    218         aetools.enumsubst(_arguments, 'rout', _Enum_bool)
    219 
    220         _reply, _arguments, _attributes = self.send(_code, _subcode,
    221                 _arguments, _attributes)
    222         if _arguments.get('errn', 0):
    223             raise aetools.Error, aetools.decodeerror(_arguments)
    224         # XXXX Optionally decode result
    225         if _arguments.has_key('----'):
    226             return _arguments['----']
    227 
    228     _argmap_open = {
    229         'using' : 'usin',
    230         'with_properties' : 'prdt',
    231     }
    232 
    233     def open(self, _object, _attributes={}, **_arguments):
    234         """open: Open the specified object(s)
    235         Required argument: list of objects to open
    236         Keyword argument using: the application file to open the object with
    237         Keyword argument with_properties: the initial values for the properties, to be included with the open command sent to the application that opens the direct object
    238         Keyword argument _attributes: AppleEvent attribute dictionary
    239         """
    240         _code = 'aevt'
    241         _subcode = 'odoc'
    242 
    243         aetools.keysubst(_arguments, self._argmap_open)
    244         _arguments['----'] = _object
    245 
    246 
    247         _reply, _arguments, _attributes = self.send(_code, _subcode,
    248                 _arguments, _attributes)
    249         if _arguments.get('errn', 0):
    250             raise aetools.Error, aetools.decodeerror(_arguments)
    251         # XXXX Optionally decode result
    252         if _arguments.has_key('----'):
    253             return _arguments['----']
    254 
    255     _argmap_print_ = {
    256         'with_properties' : 'prdt',
    257     }
    258 
    259     def print_(self, _object, _attributes={}, **_arguments):
    260         """print: Print the specified object(s)
    261         Required argument: list of objects to print
    262         Keyword argument with_properties: optional properties to be included with the print command sent to the application that prints the direct object
    263         Keyword argument _attributes: AppleEvent attribute dictionary
    264         """
    265         _code = 'aevt'
    266         _subcode = 'pdoc'
    267 
    268         aetools.keysubst(_arguments, self._argmap_print_)
    269         _arguments['----'] = _object
    270 
    271 
    272         _reply, _arguments, _attributes = self.send(_code, _subcode,
    273                 _arguments, _attributes)
    274         if _arguments.get('errn', 0):
    275             raise aetools.Error, aetools.decodeerror(_arguments)
    276         # XXXX Optionally decode result
    277         if _arguments.has_key('----'):
    278             return _arguments['----']
    279 
    280     def quit(self, _no_object=None, _attributes={}, **_arguments):
    281         """quit: Quit the Finder
    282         Keyword argument _attributes: AppleEvent attribute dictionary
    283         """
    284         _code = 'aevt'
    285         _subcode = 'quit'
    286 
    287         if _arguments: raise TypeError, 'No optional args expected'
    288         if _no_object is not None: raise TypeError, 'No direct arg expected'
    289 
    290 
    291         _reply, _arguments, _attributes = self.send(_code, _subcode,
    292                 _arguments, _attributes)
    293         if _arguments.get('errn', 0):
    294             raise aetools.Error, aetools.decodeerror(_arguments)
    295         # XXXX Optionally decode result
    296         if _arguments.has_key('----'):
    297             return _arguments['----']
    298 
    299     def select(self, _object, _attributes={}, **_arguments):
    300         """select: Select the specified object(s)
    301         Required argument: the object to select
    302         Keyword argument _attributes: AppleEvent attribute dictionary
    303         """
    304         _code = 'misc'
    305         _subcode = 'slct'
    306 
    307         if _arguments: raise TypeError, 'No optional args expected'
    308         _arguments['----'] = _object
    309 
    310 
    311         _reply, _arguments, _attributes = self.send(_code, _subcode,
    312                 _arguments, _attributes)
    313         if _arguments.get('errn', 0):
    314             raise aetools.Error, aetools.decodeerror(_arguments)
    315         # XXXX Optionally decode result
    316         if _arguments.has_key('----'):
    317             return _arguments['----']
    318 
    319 _Enum_list = None # XXXX enum list not found!!
    320 _Enum_bool = None # XXXX enum bool not found!!
    321 
    322 #
    323 # Indices of types declared in this module
    324 #
    325 _classdeclarations = {
    326 }
    327 
    328 _propdeclarations = {
    329 }
    330 
    331 _compdeclarations = {
    332 }
    333 
    334 _enumdeclarations = {
    335 }
    336