1 """Suite AppleScript Suite: Standard terms for AppleScript

     2 Level 1, version 1

     3 

     4 Generated from /Volumes/Sap/System Folder/Extensions/AppleScript

     5 AETE/AEUT resource version 1/0, language 0, script 0

     6 """

     7 

     8 import aetools

     9 import MacOS

    10 

    11 _code = 'ascr'

    12 

    13 class AppleScript_Suite_Events:

    14 

    15     def _26_(self, _object, _attributes={}, **_arguments):

    16         """&: Concatenation

    17         Required argument: an AE object reference

    18         Keyword argument _attributes: AppleEvent attribute dictionary

    19         Returns: anything

    20         """

    21         _code = 'ascr'

    22         _subcode = 'ccat'

    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     def _2a_(self, _object, _attributes={}, **_arguments):

    37         """*: Multiplication

    38         Required argument: an AE object reference

    39         Keyword argument _attributes: AppleEvent attribute dictionary

    40         Returns: anything

    41         """

    42         _code = 'ascr'

    43         _subcode = '*   '

    44 

    45         if _arguments: raise TypeError, 'No optional args expected'

    46         _arguments['----'] = _object

    47 

    48 

    49         _reply, _arguments, _attributes = self.send(_code, _subcode,

    50                 _arguments, _attributes)

    51         if _arguments.get('errn', 0):

    52             raise aetools.Error, aetools.decodeerror(_arguments)

    53         # XXXX Optionally decode result

    54         if _arguments.has_key('----'):

    55             return _arguments['----']

    56 

    57     def _2b_(self, _object, _attributes={}, **_arguments):

    58         """+: Addition

    59         Required argument: an AE object reference

    60         Keyword argument _attributes: AppleEvent attribute dictionary

    61         Returns: anything

    62         """

    63         _code = 'ascr'

    64         _subcode = '+   '

    65 

    66         if _arguments: raise TypeError, 'No optional args expected'

    67         _arguments['----'] = _object

    68 

    69 

    70         _reply, _arguments, _attributes = self.send(_code, _subcode,

    71                 _arguments, _attributes)

    72         if _arguments.get('errn', 0):

    73             raise aetools.Error, aetools.decodeerror(_arguments)

    74         # XXXX Optionally decode result

    75         if _arguments.has_key('----'):

    76             return _arguments['----']

    77 

    78     def _2d_(self, _object, _attributes={}, **_arguments):

    79         """-: Subtraction

    80         Required argument: an AE object reference

    81         Keyword argument _attributes: AppleEvent attribute dictionary

    82         Returns: anything

    83         """

    84         _code = 'ascr'

    85         _subcode = '-   '

    86 

    87         if _arguments: raise TypeError, 'No optional args expected'

    88         _arguments['----'] = _object

    89 

    90 

    91         _reply, _arguments, _attributes = self.send(_code, _subcode,

    92                 _arguments, _attributes)

    93         if _arguments.get('errn', 0):

    94             raise aetools.Error, aetools.decodeerror(_arguments)

    95         # XXXX Optionally decode result

    96         if _arguments.has_key('----'):

    97             return _arguments['----']

    98 

    99     def _3c_(self, _object, _attributes={}, **_arguments):

   100         """<: Less than

   101         Required argument: an AE object reference

   102         Keyword argument _attributes: AppleEvent attribute dictionary

   103         Returns: anything

   104         """

   105         _code = 'ascr'

   106         _subcode = '<   '

   107 

   108         if _arguments: raise TypeError, 'No optional args expected'

   109         _arguments['----'] = _object

   110 

   111 

   112         _reply, _arguments, _attributes = self.send(_code, _subcode,

   113                 _arguments, _attributes)

   114         if _arguments.get('errn', 0):

   115             raise aetools.Error, aetools.decodeerror(_arguments)

   116         # XXXX Optionally decode result

   117         if _arguments.has_key('----'):

   118             return _arguments['----']

   119 

   120     def _3d_(self, _object, _attributes={}, **_arguments):

   121         """=: Equality

   122         Required argument: an AE object reference

   123         Keyword argument _attributes: AppleEvent attribute dictionary

   124         Returns: anything

   125         """

   126         _code = 'ascr'

   127         _subcode = '=   '

   128 

   129         if _arguments: raise TypeError, 'No optional args expected'

   130         _arguments['----'] = _object

   131 

   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 _3e_(self, _object, _attributes={}, **_arguments):

   142         """>: Greater than

   143         Required argument: an AE object reference

   144         Keyword argument _attributes: AppleEvent attribute dictionary

   145         Returns: anything

   146         """

   147         _code = 'ascr'

   148         _subcode = '>   '

   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_Call_a5_subroutine = {

   163         'at' : 'at  ',

   164         'from_' : 'from',

   165         'for_' : 'for ',

   166         'to' : 'to  ',

   167         'thru' : 'thru',

   168         'through' : 'thgh',

   169         'by' : 'by  ',

   170         'on' : 'on  ',

   171         'into' : 'into',

   172         'onto' : 'onto',

   173         'between' : 'btwn',

   174         'against' : 'agst',

   175         'out_of' : 'outo',

   176         'instead_of' : 'isto',

   177         'aside_from' : 'asdf',

   178         'around' : 'arnd',

   179         'beside' : 'bsid',

   180         'beneath' : 'bnth',

   181         'under' : 'undr',

   182         'over' : 'over',

   183         'above' : 'abve',

   184         'below' : 'belw',

   185         'apart_from' : 'aprt',

   186         'about' : 'abou',

   187         'since' : 'snce',

   188         'given' : 'givn',

   189         'with' : 'with',

   190         'without' : 'wout',

   191     }

   192 

   193     def Call_a5_subroutine(self, _object=None, _attributes={}, **_arguments):

   194         """Call\xa5subroutine: A subroutine call

   195         Required argument: anything

   196         Keyword argument at: a preposition

   197         Keyword argument from_: a preposition

   198         Keyword argument for_: a preposition

   199         Keyword argument to: a preposition

   200         Keyword argument thru: a preposition

   201         Keyword argument through: a preposition

   202         Keyword argument by: a preposition

   203         Keyword argument on: a preposition

   204         Keyword argument into: a preposition

   205         Keyword argument onto: a preposition

   206         Keyword argument between: a preposition

   207         Keyword argument against: a preposition

   208         Keyword argument out_of: a preposition

   209         Keyword argument instead_of: a preposition

   210         Keyword argument aside_from: a preposition

   211         Keyword argument around: a preposition

   212         Keyword argument beside: a preposition

   213         Keyword argument beneath: a preposition

   214         Keyword argument under: a preposition

   215         Keyword argument over: a preposition

   216         Keyword argument above: a preposition

   217         Keyword argument below: a preposition

   218         Keyword argument apart_from: a preposition

   219         Keyword argument about: a preposition

   220         Keyword argument since: a preposition

   221         Keyword argument given: parameter:value pairs, comma-separated

   222         Keyword argument with: formal parameter set to true if matching actual parameter is provided

   223         Keyword argument without: formal parameter set to false if matching actual parmeter is provided

   224         Keyword argument _attributes: AppleEvent attribute dictionary

   225         Returns: anything

   226         """

   227         _code = 'ascr'

   228         _subcode = 'psbr'

   229 

   230         aetools.keysubst(_arguments, self._argmap_Call_a5_subroutine)

   231         _arguments['----'] = _object

   232 

   233 

   234         _reply, _arguments, _attributes = self.send(_code, _subcode,

   235                 _arguments, _attributes)

   236         if _arguments.get('errn', 0):

   237             raise aetools.Error, aetools.decodeerror(_arguments)

   238         # XXXX Optionally decode result

   239         if _arguments.has_key('----'):

   240             return _arguments['----']

   241 

   242     def _5e_(self, _object, _attributes={}, **_arguments):

   243         """^: Exponentiation

   244         Required argument: an AE object reference

   245         Keyword argument _attributes: AppleEvent attribute dictionary

   246         Returns: anything

   247         """

   248         _code = 'ascr'

   249         _subcode = '^   '

   250 

   251         if _arguments: raise TypeError, 'No optional args expected'

   252         _arguments['----'] = _object

   253 

   254 

   255         _reply, _arguments, _attributes = self.send(_code, _subcode,

   256                 _arguments, _attributes)

   257         if _arguments.get('errn', 0):

   258             raise aetools.Error, aetools.decodeerror(_arguments)

   259         # XXXX Optionally decode result

   260         if _arguments.has_key('----'):

   261             return _arguments['----']

   262 

   263     def activate(self, _no_object=None, _attributes={}, **_arguments):

   264         """activate: Bring the targeted application program to the front

   265         Keyword argument _attributes: AppleEvent attribute dictionary

   266         """

   267         _code = 'misc'

   268         _subcode = 'actv'

   269 

   270         if _arguments: raise TypeError, 'No optional args expected'

   271         if _no_object is not None: raise TypeError, 'No direct arg expected'

   272 

   273 

   274         _reply, _arguments, _attributes = self.send(_code, _subcode,

   275                 _arguments, _attributes)

   276         if _arguments.get('errn', 0):

   277             raise aetools.Error, aetools.decodeerror(_arguments)

   278         # XXXX Optionally decode result

   279         if _arguments.has_key('----'):

   280             return _arguments['----']

   281 

   282     def and_(self, _object, _attributes={}, **_arguments):

   283         """and: Logical conjunction

   284         Required argument: an AE object reference

   285         Keyword argument _attributes: AppleEvent attribute dictionary

   286         Returns: anything

   287         """

   288         _code = 'ascr'

   289         _subcode = 'AND '

   290 

   291         if _arguments: raise TypeError, 'No optional args expected'

   292         _arguments['----'] = _object

   293 

   294 

   295         _reply, _arguments, _attributes = self.send(_code, _subcode,

   296                 _arguments, _attributes)

   297         if _arguments.get('errn', 0):

   298             raise aetools.Error, aetools.decodeerror(_arguments)

   299         # XXXX Optionally decode result

   300         if _arguments.has_key('----'):

   301             return _arguments['----']

   302 

   303     def as_(self, _object, _attributes={}, **_arguments):

   304         """as: Coercion

   305         Required argument: an AE object reference

   306         Keyword argument _attributes: AppleEvent attribute dictionary

   307         Returns: anything

   308         """

   309         _code = 'ascr'

   310         _subcode = 'coer'

   311 

   312         if _arguments: raise TypeError, 'No optional args expected'

   313         _arguments['----'] = _object

   314 

   315 

   316         _reply, _arguments, _attributes = self.send(_code, _subcode,

   317                 _arguments, _attributes)

   318         if _arguments.get('errn', 0):

   319             raise aetools.Error, aetools.decodeerror(_arguments)

   320         # XXXX Optionally decode result

   321         if _arguments.has_key('----'):

   322             return _arguments['----']

   323 

   324     def contains(self, _object, _attributes={}, **_arguments):

   325         """contains: Containment

   326         Required argument: an AE object reference

   327         Keyword argument _attributes: AppleEvent attribute dictionary

   328         Returns: anything

   329         """

   330         _code = 'ascr'

   331         _subcode = 'cont'

   332 

   333         if _arguments: raise TypeError, 'No optional args expected'

   334         _arguments['----'] = _object

   335 

   336 

   337         _reply, _arguments, _attributes = self.send(_code, _subcode,

   338                 _arguments, _attributes)

   339         if _arguments.get('errn', 0):

   340             raise aetools.Error, aetools.decodeerror(_arguments)

   341         # XXXX Optionally decode result

   342         if _arguments.has_key('----'):

   343             return _arguments['----']

   344 

   345     def div(self, _object, _attributes={}, **_arguments):

   346         """div: Quotient

   347         Required argument: an AE object reference

   348         Keyword argument _attributes: AppleEvent attribute dictionary

   349         Returns: anything

   350         """

   351         _code = 'ascr'

   352         _subcode = 'div '

   353 

   354         if _arguments: raise TypeError, 'No optional args expected'

   355         _arguments['----'] = _object

   356 

   357 

   358         _reply, _arguments, _attributes = self.send(_code, _subcode,

   359                 _arguments, _attributes)

   360         if _arguments.get('errn', 0):

   361             raise aetools.Error, aetools.decodeerror(_arguments)

   362         # XXXX Optionally decode result

   363         if _arguments.has_key('----'):

   364             return _arguments['----']

   365 

   366     def end_tell(self, _no_object=None, _attributes={}, **_arguments):

   367         """end tell: Record or log an \xd4end tell\xd5 statement

   368         Keyword argument _attributes: AppleEvent attribute dictionary

   369         """

   370         _code = 'ascr'

   371         _subcode = 'tend'

   372 

   373         if _arguments: raise TypeError, 'No optional args expected'

   374         if _no_object is not None: raise TypeError, 'No direct arg expected'

   375 

   376 

   377         _reply, _arguments, _attributes = self.send(_code, _subcode,

   378                 _arguments, _attributes)

   379         if _arguments.get('errn', 0):

   380             raise aetools.Error, aetools.decodeerror(_arguments)

   381         # XXXX Optionally decode result

   382         if _arguments.has_key('----'):

   383             return _arguments['----']

   384 

   385     def ends_with(self, _object, _attributes={}, **_arguments):

   386         """ends with: Ends with

   387         Required argument: an AE object reference

   388         Keyword argument _attributes: AppleEvent attribute dictionary

   389         Returns: anything

   390         """

   391         _code = 'ascr'

   392         _subcode = 'ends'

   393 

   394         if _arguments: raise TypeError, 'No optional args expected'

   395         _arguments['----'] = _object

   396 

   397 

   398         _reply, _arguments, _attributes = self.send(_code, _subcode,

   399                 _arguments, _attributes)

   400         if _arguments.get('errn', 0):

   401             raise aetools.Error, aetools.decodeerror(_arguments)

   402         # XXXX Optionally decode result

   403         if _arguments.has_key('----'):

   404             return _arguments['----']

   405 

   406     _argmap_error = {

   407         'number' : 'errn',

   408         'partial_result' : 'ptlr',

   409         'from_' : 'erob',

   410         'to' : 'errt',

   411     }

   412 

   413     def error(self, _object=None, _attributes={}, **_arguments):

   414         """error: Raise an error

   415         Required argument: anything

   416         Keyword argument number: an error number

   417         Keyword argument partial_result: any partial result occurring before the error

   418         Keyword argument from_: the object that caused the error

   419         Keyword argument to: the desired class for a failed coercion

   420         Keyword argument _attributes: AppleEvent attribute dictionary

   421         """

   422         _code = 'ascr'

   423         _subcode = 'err '

   424 

   425         aetools.keysubst(_arguments, self._argmap_error)

   426         _arguments['----'] = _object

   427 

   428 

   429         _reply, _arguments, _attributes = self.send(_code, _subcode,

   430                 _arguments, _attributes)

   431         if _arguments.get('errn', 0):

   432             raise aetools.Error, aetools.decodeerror(_arguments)

   433         # XXXX Optionally decode result

   434         if _arguments.has_key('----'):

   435             return _arguments['----']

   436 

   437     def idle(self, _no_object=None, _attributes={}, **_arguments):

   438         """idle: Sent to a script application when it is idle

   439         Keyword argument _attributes: AppleEvent attribute dictionary

   440         Returns: the number of seconds to wait for next idle event

   441         """

   442         _code = 'misc'

   443         _subcode = 'idle'

   444 

   445         if _arguments: raise TypeError, 'No optional args expected'

   446         if _no_object is not None: raise TypeError, 'No direct arg expected'

   447 

   448 

   449         _reply, _arguments, _attributes = self.send(_code, _subcode,

   450                 _arguments, _attributes)

   451         if _arguments.get('errn', 0):

   452             raise aetools.Error, aetools.decodeerror(_arguments)

   453         # XXXX Optionally decode result

   454         if _arguments.has_key('----'):

   455             return _arguments['----']

   456 

   457     def launch(self, _no_object=None, _attributes={}, **_arguments):

   458         """launch: Start an application for scripting

   459         Keyword argument _attributes: AppleEvent attribute dictionary

   460         """

   461         _code = 'ascr'

   462         _subcode = 'noop'

   463 

   464         if _arguments: raise TypeError, 'No optional args expected'

   465         if _no_object is not None: raise TypeError, 'No direct arg expected'

   466 

   467 

   468         _reply, _arguments, _attributes = self.send(_code, _subcode,

   469                 _arguments, _attributes)

   470         if _arguments.get('errn', 0):

   471             raise aetools.Error, aetools.decodeerror(_arguments)

   472         # XXXX Optionally decode result

   473         if _arguments.has_key('----'):

   474             return _arguments['----']

   475 

   476     def log(self, _object, _attributes={}, **_arguments):

   477         """log: Cause a comment to be logged

   478         Required argument: undocumented, typecode 'TEXT'

   479         Keyword argument _attributes: AppleEvent attribute dictionary

   480         """

   481         _code = 'ascr'

   482         _subcode = 'cmnt'

   483 

   484         if _arguments: raise TypeError, 'No optional args expected'

   485         _arguments['----'] = _object

   486 

   487 

   488         _reply, _arguments, _attributes = self.send(_code, _subcode,

   489                 _arguments, _attributes)

   490         if _arguments.get('errn', 0):

   491             raise aetools.Error, aetools.decodeerror(_arguments)

   492         # XXXX Optionally decode result

   493         if _arguments.has_key('----'):

   494             return _arguments['----']

   495 

   496     def mod(self, _object, _attributes={}, **_arguments):

   497         """mod: Remainder

   498         Required argument: an AE object reference

   499         Keyword argument _attributes: AppleEvent attribute dictionary

   500         Returns: anything

   501         """

   502         _code = 'ascr'

   503         _subcode = 'mod '

   504 

   505         if _arguments: raise TypeError, 'No optional args expected'

   506         _arguments['----'] = _object

   507 

   508 

   509         _reply, _arguments, _attributes = self.send(_code, _subcode,

   510                 _arguments, _attributes)

   511         if _arguments.get('errn', 0):

   512             raise aetools.Error, aetools.decodeerror(_arguments)

   513         # XXXX Optionally decode result

   514         if _arguments.has_key('----'):

   515             return _arguments['----']

   516 

   517     def negate(self, _object, _attributes={}, **_arguments):

   518         """negate: Numeric negation

   519         Required argument: an AE object reference

   520         Keyword argument _attributes: AppleEvent attribute dictionary

   521         Returns: anything

   522         """

   523         _code = 'ascr'

   524         _subcode = 'neg '

   525 

   526         if _arguments: raise TypeError, 'No optional args expected'

   527         _arguments['----'] = _object

   528 

   529 

   530         _reply, _arguments, _attributes = self.send(_code, _subcode,

   531                 _arguments, _attributes)

   532         if _arguments.get('errn', 0):

   533             raise aetools.Error, aetools.decodeerror(_arguments)

   534         # XXXX Optionally decode result

   535         if _arguments.has_key('----'):

   536             return _arguments['----']

   537 

   538     def not_(self, _object, _attributes={}, **_arguments):

   539         """not: Logical negation

   540         Required argument: an AE object reference

   541         Keyword argument _attributes: AppleEvent attribute dictionary

   542         Returns: anything

   543         """

   544         _code = 'ascr'

   545         _subcode = 'NOT '

   546 

   547         if _arguments: raise TypeError, 'No optional args expected'

   548         _arguments['----'] = _object

   549 

   550 

   551         _reply, _arguments, _attributes = self.send(_code, _subcode,

   552                 _arguments, _attributes)

   553         if _arguments.get('errn', 0):

   554             raise aetools.Error, aetools.decodeerror(_arguments)

   555         # XXXX Optionally decode result

   556         if _arguments.has_key('----'):

   557             return _arguments['----']

   558 

   559     def or_(self, _object, _attributes={}, **_arguments):

   560         """or: Logical disjunction

   561         Required argument: an AE object reference

   562         Keyword argument _attributes: AppleEvent attribute dictionary

   563         Returns: anything

   564         """

   565         _code = 'ascr'

   566         _subcode = 'OR  '

   567 

   568         if _arguments: raise TypeError, 'No optional args expected'

   569         _arguments['----'] = _object

   570 

   571 

   572         _reply, _arguments, _attributes = self.send(_code, _subcode,

   573                 _arguments, _attributes)

   574         if _arguments.get('errn', 0):

   575             raise aetools.Error, aetools.decodeerror(_arguments)

   576         # XXXX Optionally decode result

   577         if _arguments.has_key('----'):

   578             return _arguments['----']

   579 

   580     def start_log(self, _no_object=None, _attributes={}, **_arguments):

   581         """start log: Start event logging in the script editor

   582         Keyword argument _attributes: AppleEvent attribute dictionary

   583         """

   584         _code = 'ToyS'

   585         _subcode = 'log1'

   586 

   587         if _arguments: raise TypeError, 'No optional args expected'

   588         if _no_object is not None: raise TypeError, 'No direct arg expected'

   589 

   590 

   591         _reply, _arguments, _attributes = self.send(_code, _subcode,

   592                 _arguments, _attributes)

   593         if _arguments.get('errn', 0):

   594             raise aetools.Error, aetools.decodeerror(_arguments)

   595         # XXXX Optionally decode result

   596         if _arguments.has_key('----'):

   597             return _arguments['----']

   598 

   599     def starts_with(self, _object, _attributes={}, **_arguments):

   600         """starts with: Starts with

   601         Required argument: an AE object reference

   602         Keyword argument _attributes: AppleEvent attribute dictionary

   603         Returns: anything

   604         """

   605         _code = 'ascr'

   606         _subcode = 'bgwt'

   607 

   608         if _arguments: raise TypeError, 'No optional args expected'

   609         _arguments['----'] = _object

   610 

   611 

   612         _reply, _arguments, _attributes = self.send(_code, _subcode,

   613                 _arguments, _attributes)

   614         if _arguments.get('errn', 0):

   615             raise aetools.Error, aetools.decodeerror(_arguments)

   616         # XXXX Optionally decode result

   617         if _arguments.has_key('----'):

   618             return _arguments['----']

   619 

   620     def stop_log(self, _no_object=None, _attributes={}, **_arguments):

   621         """stop log: Stop event logging in the script editor

   622         Keyword argument _attributes: AppleEvent attribute dictionary

   623         """

   624         _code = 'ToyS'

   625         _subcode = 'log0'

   626 

   627         if _arguments: raise TypeError, 'No optional args expected'

   628         if _no_object is not None: raise TypeError, 'No direct arg expected'

   629 

   630 

   631         _reply, _arguments, _attributes = self.send(_code, _subcode,

   632                 _arguments, _attributes)

   633         if _arguments.get('errn', 0):

   634             raise aetools.Error, aetools.decodeerror(_arguments)

   635         # XXXX Optionally decode result

   636         if _arguments.has_key('----'):

   637             return _arguments['----']

   638 

   639     def tell(self, _no_object=None, _attributes={}, **_arguments):

   640         """tell: Record or log a \xd4tell\xd5 statement

   641         Keyword argument _attributes: AppleEvent attribute dictionary

   642         """

   643         _code = 'ascr'

   644         _subcode = 'tell'

   645 

   646         if _arguments: raise TypeError, 'No optional args expected'

   647         if _no_object is not None: raise TypeError, 'No direct arg expected'

   648 

   649 

   650         _reply, _arguments, _attributes = self.send(_code, _subcode,

   651                 _arguments, _attributes)

   652         if _arguments.get('errn', 0):

   653             raise aetools.Error, aetools.decodeerror(_arguments)

   654         # XXXX Optionally decode result

   655         if _arguments.has_key('----'):

   656             return _arguments['----']

   657 

   658     def _ad_(self, _object, _attributes={}, **_arguments):

   659         """\xad: Inequality

   660         Required argument: an AE object reference

   661         Keyword argument _attributes: AppleEvent attribute dictionary

   662         Returns: anything

   663         """

   664         _code = 'ascr'

   665         _subcode = '\xad   '

   666 

   667         if _arguments: raise TypeError, 'No optional args expected'

   668         _arguments['----'] = _object

   669 

   670 

   671         _reply, _arguments, _attributes = self.send(_code, _subcode,

   672                 _arguments, _attributes)

   673         if _arguments.get('errn', 0):

   674             raise aetools.Error, aetools.decodeerror(_arguments)

   675         # XXXX Optionally decode result

   676         if _arguments.has_key('----'):

   677             return _arguments['----']

   678 

   679     def _b2_(self, _object, _attributes={}, **_arguments):

   680         """\xb2: Less than or equal to

   681         Required argument: an AE object reference

   682         Keyword argument _attributes: AppleEvent attribute dictionary

   683         Returns: anything

   684         """

   685         _code = 'ascr'

   686         _subcode = '<=  '

   687 

   688         if _arguments: raise TypeError, 'No optional args expected'

   689         _arguments['----'] = _object

   690 

   691 

   692         _reply, _arguments, _attributes = self.send(_code, _subcode,

   693                 _arguments, _attributes)

   694         if _arguments.get('errn', 0):

   695             raise aetools.Error, aetools.decodeerror(_arguments)

   696         # XXXX Optionally decode result

   697         if _arguments.has_key('----'):

   698             return _arguments['----']

   699 

   700     def _b3_(self, _object, _attributes={}, **_arguments):

   701         """\xb3: Greater than or equal to

   702         Required argument: an AE object reference

   703         Keyword argument _attributes: AppleEvent attribute dictionary

   704         Returns: anything

   705         """

   706         _code = 'ascr'

   707         _subcode = '>=  '

   708 

   709         if _arguments: raise TypeError, 'No optional args expected'

   710         _arguments['----'] = _object

   711 

   712 

   713         _reply, _arguments, _attributes = self.send(_code, _subcode,

   714                 _arguments, _attributes)

   715         if _arguments.get('errn', 0):

   716             raise aetools.Error, aetools.decodeerror(_arguments)

   717         # XXXX Optionally decode result

   718         if _arguments.has_key('----'):

   719             return _arguments['----']

   720 

   721     def _d6_(self, _object, _attributes={}, **_arguments):

   722         """\xd6: Division

   723         Required argument: an AE object reference

   724         Keyword argument _attributes: AppleEvent attribute dictionary

   725         Returns: anything

   726         """

   727         _code = 'ascr'

   728         _subcode = '/   '

   729 

   730         if _arguments: raise TypeError, 'No optional args expected'

   731         _arguments['----'] = _object

   732 

   733 

   734         _reply, _arguments, _attributes = self.send(_code, _subcode,

   735                 _arguments, _attributes)

   736         if _arguments.get('errn', 0):

   737             raise aetools.Error, aetools.decodeerror(_arguments)

   738         # XXXX Optionally decode result

   739         if _arguments.has_key('----'):

   740             return _arguments['----']

   741 

   742 

   743 class anything(aetools.ComponentItem):

   744     """anything - any class or reference """

   745     want = '****'

   746 

   747 class pictures(aetools.ComponentItem):

   748     """pictures -  """

   749     want = 'PICT'

   750 

   751 picture = pictures

   752 

   753 class styled_text(aetools.ComponentItem):

   754     """styled text - text with font, size, and style information """

   755     want = 'STXT'

   756 

   757 styled_text = styled_text

   758 

   759 class strings(aetools.ComponentItem):

   760     """strings -  """

   761     want = 'TEXT'

   762 

   763 string = strings

   764 

   765 class alias(aetools.ComponentItem):

   766     """alias - a file on a disk or server.  The file must exist when you check the syntax of your script. """

   767     want = 'alis'

   768 class _Prop_POSIX_path(aetools.NProperty):

   769     """POSIX path - the POSIX path of the file """

   770     which = 'psxp'

   771     want = 'TEXT'

   772 

   773 aliases = alias

   774 

   775 class April(aetools.ComponentItem):

   776     """April - the month of April """

   777     want = 'apr '

   778 

   779 class August(aetools.ComponentItem):

   780     """August - the month of August """

   781     want = 'aug '

   782 

   783 class booleans(aetools.ComponentItem):

   784     """booleans -  """

   785     want = 'bool'

   786 

   787 boolean = booleans

   788 

   789 class RGB_colors(aetools.ComponentItem):

   790     """RGB colors -  """

   791     want = 'cRGB'

   792 

   793 RGB_color = RGB_colors

   794 

   795 class application(aetools.ComponentItem):

   796     """application - specifies global properties of AppleScript """

   797     want = 'capp'

   798 class _Prop_AppleScript(aetools.NProperty):

   799     """AppleScript - the top-level script object """

   800     which = 'ascr'

   801     want = 'scpt'

   802 AppleScript = _Prop_AppleScript()

   803 class _Prop_days(aetools.NProperty):

   804     """days - the number of seconds in a day """

   805     which = 'days'

   806     want = 'long'

   807 days = _Prop_days()

   808 class _Prop_hours(aetools.NProperty):

   809     """hours - the number of seconds in an hour """

   810     which = 'hour'

   811     want = 'long'

   812 hours = _Prop_hours()

   813 class _Prop_minutes(aetools.NProperty):

   814     """minutes - the number of seconds in a minute """

   815     which = 'min '

   816     want = 'long'

   817 minutes = _Prop_minutes()

   818 class _Prop_pi(aetools.NProperty):

   819     """pi - the constant pi """

   820     which = 'pi  '

   821     want = 'doub'

   822 pi = _Prop_pi()

   823 class _Prop_print_depth(aetools.NProperty):

   824     """print depth - the maximum depth to print """

   825     which = 'prdp'

   826     want = 'long'

   827 print_depth = _Prop_print_depth()

   828 class _Prop_print_length(aetools.NProperty):

   829     """print length - the maximum length to print """

   830     which = 'prln'

   831     want = 'long'

   832 print_length = _Prop_print_length()

   833 class _Prop_result(aetools.NProperty):

   834     """result - the last result of evaluation """

   835     which = 'rslt'

   836     want = '****'

   837 result = _Prop_result()

   838 class _Prop_return_(aetools.NProperty):

   839     """return - a return character """

   840     which = 'ret '

   841     want = 'cha '

   842 return_ = _Prop_return_()

   843 class _Prop_space(aetools.NProperty):

   844     """space - a space character """

   845     which = 'spac'

   846     want = 'cha '

   847 space = _Prop_space()

   848 class _Prop_tab(aetools.NProperty):

   849     """tab - a tab character """

   850     which = 'tab '

   851     want = 'cha '

   852 tab = _Prop_tab()

   853 class _Prop_text_item_delimiters(aetools.NProperty):

   854     """text item delimiters - the text item delimiters of a string """

   855     which = 'txdl'

   856     want = 'list'

   857 text_item_delimiters = _Prop_text_item_delimiters()

   858 class _Prop_weeks(aetools.NProperty):

   859     """weeks - the number of seconds in a week """

   860     which = 'week'

   861     want = 'long'

   862 weeks = _Prop_weeks()

   863 

   864 applications = application

   865 

   866 app = application

   867 

   868 class upper_case(aetools.ComponentItem):

   869     """upper case - Text with lower case converted to upper case """

   870     want = 'case'

   871 

   872 class cubic_centimeters(aetools.ComponentItem):

   873     """cubic centimeters - a volume measurement in SI cubic centimeters """

   874     want = 'ccmt'

   875 

   876 cubic_centimetres = cubic_centimeters

   877 

   878 class cubic_feet(aetools.ComponentItem):

   879     """cubic feet - a volume measurement in Imperial cubic feet """

   880     want = 'cfet'

   881 

   882 class characters(aetools.ComponentItem):

   883     """characters -  """

   884     want = 'cha '

   885 

   886 character = characters

   887 

   888 class writing_code_info(aetools.ComponentItem):

   889     """writing code info - script code and language code of text run """

   890     want = 'citl'

   891 class _Prop_language_code(aetools.NProperty):

   892     """language code - the language code for the text """

   893     which = 'plcd'

   894     want = 'shor'

   895 class _Prop_script_code(aetools.NProperty):

   896     """script code - the script code for the text """

   897     which = 'pscd'

   898     want = 'shor'

   899 

   900 writing_code_infos = writing_code_info

   901 

   902 class text_items(aetools.ComponentItem):

   903     """text items -  """

   904     want = 'citm'

   905 

   906 text_item = text_items

   907 

   908 class cubic_meters(aetools.ComponentItem):

   909     """cubic meters - a volume measurement in SI cubic meters """

   910     want = 'cmet'

   911 

   912 cubic_metres = cubic_meters

   913 

   914 class centimeters(aetools.ComponentItem):

   915     """centimeters - a distance measurement in SI centimeters """

   916     want = 'cmtr'

   917 

   918 centimetres = centimeters

   919 

   920 class item(aetools.ComponentItem):

   921     """item - An item of any type """

   922     want = 'cobj'

   923 class _Prop_id(aetools.NProperty):

   924     """id - the unique ID number of this object """

   925     which = 'ID  '

   926     want = 'long'

   927 

   928 items = item

   929 

   930 class C_strings(aetools.ComponentItem):

   931     """C strings -  """

   932     want = 'cstr'

   933 

   934 C_string = C_strings

   935 

   936 class text(aetools.ComponentItem):

   937     """text - text with language and style information """

   938     want = 'ctxt'

   939 

   940 class cubic_inches(aetools.ComponentItem):

   941     """cubic inches - a volume measurement in Imperial cubic inches """

   942     want = 'cuin'

   943 

   944 class cubic_yards(aetools.ComponentItem):

   945     """cubic yards - a distance measurement in Imperial cubic yards """

   946     want = 'cyrd'

   947 

   948 class December(aetools.ComponentItem):

   949     """December - the month of December """

   950     want = 'dec '

   951 

   952 class degrees_Celsius(aetools.ComponentItem):

   953     """degrees Celsius - a temperature measurement in SI degrees Celsius """

   954     want = 'degc'

   955 

   956 class degrees_Fahrenheit(aetools.ComponentItem):

   957     """degrees Fahrenheit - a temperature measurement in degrees Fahrenheit """

   958     want = 'degf'

   959 

   960 class degrees_Kelvin(aetools.ComponentItem):

   961     """degrees Kelvin - a temperature measurement in degrees Kelvin """

   962     want = 'degk'

   963 

   964 class reals(aetools.ComponentItem):

   965     """reals -  """

   966     want = 'doub'

   967 

   968 real = reals

   969 

   970 class encoded_strings(aetools.ComponentItem):

   971     """encoded strings -  """

   972     want = 'encs'

   973 

   974 encoded_string = encoded_strings

   975 

   976 class constants(aetools.ComponentItem):

   977     """constants -  """

   978     want = 'enum'

   979 

   980 constant = constants

   981 

   982 class events(aetools.ComponentItem):

   983     """events -  """

   984     want = 'evnt'

   985 

   986 event = events

   987 

   988 class February(aetools.ComponentItem):

   989     """February - the month of February """

   990     want = 'feb '

   991 

   992 class feet(aetools.ComponentItem):

   993     """feet - a distance measurement in Imperial feet """

   994     want = 'feet'

   995 

   996 class Friday(aetools.ComponentItem):

   997     """Friday - Friday """

   998     want = 'fri '

   999 

  1000 class file_specification(aetools.ComponentItem):

  1001     """file specification - a file specification as used by the operating system """

  1002     want = 'fss '

  1003 

  1004 file_specifications = file_specification

  1005 

  1006 class gallons(aetools.ComponentItem):

  1007     """gallons - a volume measurement in Imperial gallons """

  1008     want = 'galn'

  1009 

  1010 class grams(aetools.ComponentItem):

  1011     """grams - a mass measurement in SI meters """

  1012     want = 'gram'

  1013 

  1014 class handlers(aetools.ComponentItem):

  1015     """handlers -  """

  1016     want = 'hand'

  1017 

  1018 handler = handlers

  1019 

  1020 class inches(aetools.ComponentItem):

  1021     """inches - a distance measurement in Imperial inches """

  1022     want = 'inch'

  1023 

  1024 class international_text(aetools.ComponentItem):

  1025     """international text - text that begins with a writing code """

  1026     want = 'itxt'

  1027 

  1028 international_text = international_text

  1029 

  1030 class January(aetools.ComponentItem):

  1031     """January - the month of January """

  1032     want = 'jan '

  1033 

  1034 class July(aetools.ComponentItem):

  1035     """July - the month of July """

  1036     want = 'jul '

  1037 

  1038 class June(aetools.ComponentItem):

  1039     """June - the month of June """

  1040     want = 'jun '

  1041 

  1042 class reference_forms(aetools.ComponentItem):

  1043     """reference forms -  """

  1044     want = 'kfrm'

  1045 

  1046 reference_form = reference_forms

  1047 

  1048 class kilograms(aetools.ComponentItem):

  1049     """kilograms - a mass measurement in SI kilograms """

  1050     want = 'kgrm'

  1051 

  1052 class kilometers(aetools.ComponentItem):

  1053     """kilometers - a distance measurement in SI kilometers """

  1054     want = 'kmtr'

  1055 

  1056 kilometres = kilometers

  1057 

  1058 class keystroke(aetools.ComponentItem):

  1059     """keystroke - a press of a key combination on a Macintosh keyboard """

  1060     want = 'kprs'

  1061 class _Prop_key(aetools.NProperty):

  1062     """key - the character for the key was pressed (ignoring modifiers) """

  1063     which = 'kMsg'

  1064     want = 'cha '

  1065 class _Prop_key_kind(aetools.NProperty):

  1066     """key kind - the kind of key that was pressed """

  1067     which = 'kknd'

  1068     want = 'ekst'

  1069 class _Prop_modifiers(aetools.NProperty):

  1070     """modifiers - the modifier keys pressed in combination """

  1071     which = 'kMod'

  1072     want = 'eMds'

  1073 

  1074 keystrokes = keystroke

  1075 

  1076 class pounds(aetools.ComponentItem):

  1077     """pounds - a weight measurement in SI meters """

  1078     want = 'lbs '

  1079 

  1080 class date(aetools.ComponentItem):

  1081     """date - Absolute date and time values """

  1082     want = 'ldt '

  1083 class _Prop_date_string(aetools.NProperty):

  1084     """date string - the date portion of a date-time value as text """

  1085     which = 'dstr'

  1086     want = 'TEXT'

  1087 class _Prop_day(aetools.NProperty):

  1088     """day - the day of the month of a date """

  1089     which = 'day '

  1090     want = 'long'

  1091 class _Prop_month(aetools.NProperty):

  1092     """month - the month of a date """

  1093     which = 'mnth'

  1094     want = 'mnth'

  1095 class _Prop_time(aetools.NProperty):

  1096     """time - the time since midnight of a date """

  1097     which = 'time'

  1098     want = 'long'

  1099 class _Prop_time_string(aetools.NProperty):

  1100     """time string - the time portion of a date-time value as text """

  1101     which = 'tstr'

  1102     want = 'TEXT'

  1103 class _Prop_weekday(aetools.NProperty):

  1104     """weekday - the day of a week of a date """

  1105     which = 'wkdy'

  1106     want = 'wkdy'

  1107 class _Prop_year(aetools.NProperty):

  1108     """year - the year of a date """

  1109     which = 'year'

  1110     want = 'long'

  1111 

  1112 dates = date

  1113 

  1114 class list(aetools.ComponentItem):

  1115     """list - An ordered collection of items """

  1116     want = 'list'

  1117 class _Prop_length(aetools.NProperty):

  1118     """length - the length of a list """

  1119     which = 'leng'

  1120     want = 'long'

  1121 class _Prop_rest(aetools.NProperty):

  1122     """rest - all items of the list excluding first """

  1123     which = 'rest'

  1124     want = 'list'

  1125 class _Prop_reverse(aetools.NProperty):

  1126     """reverse - the items of the list in reverse order """

  1127     which = 'rvse'

  1128     want = 'list'

  1129 

  1130 lists = list

  1131 

  1132 class liters(aetools.ComponentItem):

  1133     """liters - a volume measurement in SI liters """

  1134     want = 'litr'

  1135