Lib/plat-mac/lib-scriptpackages/Finder/Standard_Suite.py

   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 }