Mac/Lib/lib-scriptpackages/Explorer/Web_Browser_Suite.py

   1 """Suite Web Browser Suite: Class of events which are sent to Web Browser applications
   2 Level 1, version 1
   3
   4 Generated from Macintosh HD:Internet:Internet-programma's:Internet Explorer 4.5-map:Internet Explorer 4.5
   5 AETE/AEUT resource version 1/0, language 0, script 0
   6 """
   7
   8 import aetools
   9 import MacOS
  10
  11 _code = 'WWW!'
  12
  13 class Web_Browser_Suite_Events:
  14
  15         _argmap_OpenURL = {
  16                 'to' : 'INTO',
  17                 'toWindow' : 'WIND',
  18                 'Flags' : 'FLGS',
  19                 'FormData' : 'POST',
  20                 'MIMEType' : 'MIME',
  21                 'ProgressApp' : 'PROG',
  22                 'ResultApp' : 'RSLT',
  23         }
  24
  25         def OpenURL(self, _object, _attributes={}, **_arguments):
  26                 """OpenURL: Retrieves URL off the Web.
  27                 Required argument: Fully specified URL
  28                 Keyword argument to: File to save downloaded data into.
  29                 Keyword argument toWindow: Window to open this URL into. (Use -1 for top window, 0 for new window)
  30                 Keyword argument Flags: Valid Flags settings are: 1-Ignore the document cache; 2-Ignore the image cache; 4-Operate in background mode.
  31                 Keyword argument FormData: Posting of forms of a given MIMEType.
  32                 Keyword argument MIMEType: MIME type for the FormData.
  33                 Keyword argument ProgressApp: If specified, ProgressApp can be named to handle the user interface for process messages.
  34                 Keyword argument ResultApp: When the requested URL has been accessed and all associated documents loaded, the Web browser will issue an OpenURLResult to the ResultApp.
  35                 Keyword argument _attributes: AppleEvent attribute dictionary
  36                 Returns: TransactionID
  37                 """
  38                 _code = 'WWW!'
  39                 _subcode = 'OURL'
  40
  41                 aetools.keysubst(_arguments, self._argmap_OpenURL)
  42                 _arguments['----'] = _object
  43
  44
  45                 _reply, _arguments, _attributes = self.send(_code, _subcode,
  46                                 _arguments, _attributes)
  47                 if _arguments.has_key('errn'):
  48                         raise aetools.Error, aetools.decodeerror(_arguments)
  49                 # XXXX Optionally decode result
  50                 if _arguments.has_key('----'):
  51                         return _arguments['----']
  52
  53         _argmap_ShowFile = {
  54                 'MIME_type' : 'MIME',
  55                 'Window_ID' : 'WIND',
  56                 'URL' : 'URL ',
  57                 'ResultApp' : 'RSLT',
  58         }
  59
  60         def ShowFile(self, _object, _attributes={}, **_arguments):
  61                 """ShowFile: Passes FileSpec containing data of a given MIME type to be rendered in a given WindowID.
  62                 Required argument: The file to show.
  63                 Keyword argument MIME_type: MIME type
  64                 Keyword argument Window_ID: ID of the window to open the file into. (Can use -1 for top window)
  65                 Keyword argument URL: A URL which allows this document to be reloaded if necessary.
  66                 Keyword argument ResultApp: When the requested URL has been accessed and all associated documents loaded, the Web browser will issue a ShowFileResult to the ResultApp.
  67                 Keyword argument _attributes: AppleEvent attribute dictionary
  68                 Returns: TransactionID
  69                 """
  70                 _code = 'WWW!'
  71                 _subcode = 'SHWF'
  72
  73                 aetools.keysubst(_arguments, self._argmap_ShowFile)
  74                 _arguments['----'] = _object
  75
  76
  77                 _reply, _arguments, _attributes = self.send(_code, _subcode,
  78                                 _arguments, _attributes)
  79                 if _arguments.has_key('errn'):
  80                         raise aetools.Error, aetools.decodeerror(_arguments)
  81                 # XXXX Optionally decode result
  82                 if _arguments.has_key('----'):
  83                         return _arguments['----']
  84
  85         def CancelTransaction(self, _object, _attributes={}, **_arguments):
  86                 """CancelTransaction: Tells the Web browser to cancel a TransactionID is progress which the application has initiated via an OpenURL or ShowFile command.
  87                 Required argument: TransactionID
  88                 Keyword argument _attributes: AppleEvent attribute dictionary
  89                 """
  90                 _code = 'WWW!'
  91                 _subcode = 'CANT'
  92
  93                 if _arguments: raise TypeError, 'No optional args expected'
  94                 _arguments['----'] = _object
  95
  96
  97                 _reply, _arguments, _attributes = self.send(_code, _subcode,
  98                                 _arguments, _attributes)
  99                 if _arguments.has_key('errn'):
 100                         raise aetools.Error, aetools.decodeerror(_arguments)
 101                 # XXXX Optionally decode result
 102                 if _arguments.has_key('----'):
 103                         return _arguments['----']
 104
 105         _argmap_QueryVersion = {
 106                 'Major_Version' : 'MAJV',
 107                 'Minor_Version' : 'MINV',
 108         }
 109
 110         def QueryVersion(self, _no_object=None, _attributes={}, **_arguments):
 111                 """QueryVersion: Tells the Web browser that an application which wishes to communicate with it supports a specific version (major.minor) of this SDI specification
 112                 Keyword argument Major_Version: Major version of the SDI specification the sending application supports.
 113                 Keyword argument Minor_Version: Minor version of the SDI specification the sending application supports.
 114                 Keyword argument _attributes: AppleEvent attribute dictionary
 115                 Returns:
 116                 """
 117                 _code = 'WWW!'
 118                 _subcode = 'QVER'
 119
 120                 aetools.keysubst(_arguments, self._argmap_QueryVersion)
 121                 if _no_object != None: raise TypeError, 'No direct arg expected'
 122
 123
 124                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 125                                 _arguments, _attributes)
 126                 if _arguments.has_key('errn'):
 127                         raise aetools.Error, aetools.decodeerror(_arguments)
 128                 # XXXX Optionally decode result
 129                 if _arguments.has_key('----'):
 130                         return _arguments['----']
 131
 132         def CloseAllWindows(self, _no_object=None, _attributes={}, **_arguments):
 133                 """CloseAllWindows: Tells the Web browser to close all windows
 134                 Keyword argument _attributes: AppleEvent attribute dictionary
 135                 Returns: Success
 136                 """
 137                 _code = 'WWW!'
 138                 _subcode = 'CLSA'
 139
 140                 if _arguments: raise TypeError, 'No optional args expected'
 141                 if _no_object != None: raise TypeError, 'No direct arg expected'
 142
 143
 144                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 145                                 _arguments, _attributes)
 146                 if _arguments.has_key('errn'):
 147                         raise aetools.Error, aetools.decodeerror(_arguments)
 148                 # XXXX Optionally decode result
 149                 if _arguments.has_key('----'):
 150                         return _arguments['----']
 151
 152         _argmap_CloseWindow = {
 153                 'ID' : 'WIND',
 154                 'Title' : 'TITL',
 155         }
 156
 157         def CloseWindow(self, _no_object=None, _attributes={}, **_arguments):
 158                 """CloseWindow: Tells the Web browser to close the window specified either by Window ID or Title. If no parameters are specified, the top window will be closed.
 159                 Keyword argument ID: ID of the window to close. (Can use -1 for top window)
 160                 Keyword argument Title: Title of the window to close.
 161                 Keyword argument _attributes: AppleEvent attribute dictionary
 162                 Returns: Success
 163                 """
 164                 _code = 'WWW!'
 165                 _subcode = 'CLOS'
 166
 167                 aetools.keysubst(_arguments, self._argmap_CloseWindow)
 168                 if _no_object != None: raise TypeError, 'No direct arg expected'
 169
 170
 171                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 172                                 _arguments, _attributes)
 173                 if _arguments.has_key('errn'):
 174                         raise aetools.Error, aetools.decodeerror(_arguments)
 175                 # XXXX Optionally decode result
 176                 if _arguments.has_key('----'):
 177                         return _arguments['----']
 178
 179         _argmap_Activate = {
 180                 'Flags' : 'FLGS',
 181         }
 182
 183         def Activate(self, _object=None, _attributes={}, **_arguments):
 184                 """Activate: Tells the Web browser to bring itself to the front and show WindowID. (Can use -1 for top window)
 185                 Required argument: WindowID
 186                 Keyword argument Flags: Reserved for future use
 187                 Keyword argument _attributes: AppleEvent attribute dictionary
 188                 Returns: WindowID of the front window
 189                 """
 190                 _code = 'WWW!'
 191                 _subcode = 'ACTV'
 192
 193                 aetools.keysubst(_arguments, self._argmap_Activate)
 194                 _arguments['----'] = _object
 195
 196
 197                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 198                                 _arguments, _attributes)
 199                 if _arguments.has_key('errn'):
 200                         raise aetools.Error, aetools.decodeerror(_arguments)
 201                 # XXXX Optionally decode result
 202                 if _arguments.has_key('----'):
 203                         return _arguments['----']
 204
 205         def ListWindows(self, _no_object=None, _attributes={}, **_arguments):
 206                 """ListWindows: Return a list of WindowIDs representing each windows currently being used by the Web browser.
 207                 Keyword argument _attributes: AppleEvent attribute dictionary
 208                 Returns: undocumented, typecode 'list'
 209                 """
 210                 _code = 'WWW!'
 211                 _subcode = 'LSTW'
 212
 213                 if _arguments: raise TypeError, 'No optional args expected'
 214                 if _no_object != None: raise TypeError, 'No direct arg expected'
 215
 216
 217                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 218                                 _arguments, _attributes)
 219                 if _arguments.has_key('errn'):
 220                         raise aetools.Error, aetools.decodeerror(_arguments)
 221                 # XXXX Optionally decode result
 222                 if _arguments.has_key('----'):
 223                         return _arguments['----']
 224
 225         def GetWindowInfo(self, _object, _attributes={}, **_arguments):
 226                 """GetWindowInfo: Returns a window info record (URL/Title) for the specified window.
 227                 Required argument: WindowID of the window to get info about
 228                 Keyword argument _attributes: AppleEvent attribute dictionary
 229                 Returns:
 230                 """
 231                 _code = 'WWW!'
 232                 _subcode = 'WNFO'
 233
 234                 if _arguments: raise TypeError, 'No optional args expected'
 235                 _arguments['----'] = _object
 236
 237
 238                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 239                                 _arguments, _attributes)
 240                 if _arguments.has_key('errn'):
 241                         raise aetools.Error, aetools.decodeerror(_arguments)
 242                 # XXXX Optionally decode result
 243                 if _arguments.has_key('----'):
 244                         return _arguments['----']
 245
 246         _argmap_ParseAnchor = {
 247                 'withURL' : 'RELA',
 248         }
 249
 250         def ParseAnchor(self, _object, _attributes={}, **_arguments):
 251                 """ParseAnchor: Combine a base URL and a relative URL to produce a fully-specified URL
 252                 Required argument: MainURL.The base URL.
 253                 Keyword argument withURL: RelativeURL, which, when combined with the MainURL (in the direct object), is used to produce a fully-specified URL.
 254                 Keyword argument _attributes: AppleEvent attribute dictionary
 255                 Returns: The Fully specified URL
 256                 """
 257                 _code = 'WWW!'
 258                 _subcode = 'PRSA'
 259
 260                 aetools.keysubst(_arguments, self._argmap_ParseAnchor)
 261                 _arguments['----'] = _object
 262
 263
 264                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 265                                 _arguments, _attributes)
 266                 if _arguments.has_key('errn'):
 267                         raise aetools.Error, aetools.decodeerror(_arguments)
 268                 # XXXX Optionally decode result
 269                 if _arguments.has_key('----'):
 270                         return _arguments['----']
 271
 272         _argmap_BeginProgress = {
 273                 'with_Message' : 'PMSG',
 274         }
 275
 276         def BeginProgress(self, _object, _attributes={}, **_arguments):
 277                 """BeginProgress: Initialize a progress indicator.
 278                 Required argument: TransactionID
 279                 Keyword argument with_Message: Message to display with the progress indicator.
 280                 Keyword argument _attributes: AppleEvent attribute dictionary
 281                 Returns: Success
 282                 """
 283                 _code = 'WWW!'
 284                 _subcode = 'PRBG'
 285
 286                 aetools.keysubst(_arguments, self._argmap_BeginProgress)
 287                 _arguments['----'] = _object
 288
 289
 290                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 291                                 _arguments, _attributes)
 292                 if _arguments.has_key('errn'):
 293                         raise aetools.Error, aetools.decodeerror(_arguments)
 294                 # XXXX Optionally decode result
 295                 if _arguments.has_key('----'):
 296                         return _arguments['----']
 297
 298         _argmap_SetProgressRange = {
 299                 'Max' : 'MAXV',
 300         }
 301
 302         def SetProgressRange(self, _object, _attributes={}, **_arguments):
 303                 """SetProgressRange: Sets a max value for the progress indicator associated with TransactionID
 304                 Required argument: TransactionID
 305                 Keyword argument Max: Max value for this progress indicator
 306                 Keyword argument _attributes: AppleEvent attribute dictionary
 307                 """
 308                 _code = 'WWW!'
 309                 _subcode = 'PRSR'
 310
 311                 aetools.keysubst(_arguments, self._argmap_SetProgressRange)
 312                 _arguments['----'] = _object
 313
 314
 315                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 316                                 _arguments, _attributes)
 317                 if _arguments.has_key('errn'):
 318                         raise aetools.Error, aetools.decodeerror(_arguments)
 319                 # XXXX Optionally decode result
 320                 if _arguments.has_key('----'):
 321                         return _arguments['----']
 322
 323         _argmap_MakingProgress = {
 324                 'with_message' : 'PMSG',
 325                 'current_setting' : 'CURR',
 326         }
 327
 328         def MakingProgress(self, _object, _attributes={}, **_arguments):
 329                 """MakingProgress: Updates the progress indicator associated with TransactionID
 330                 Required argument: TransactionID
 331                 Keyword argument with_message: Message to display in the progress indicator
 332                 Keyword argument current_setting: Current value of the progress indicator
 333                 Keyword argument _attributes: AppleEvent attribute dictionary
 334                 Returns: Cancel
 335                 """
 336                 _code = 'WWW!'
 337                 _subcode = 'PRMK'
 338
 339                 aetools.keysubst(_arguments, self._argmap_MakingProgress)
 340                 _arguments['----'] = _object
 341
 342
 343                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 344                                 _arguments, _attributes)
 345                 if _arguments.has_key('errn'):
 346                         raise aetools.Error, aetools.decodeerror(_arguments)
 347                 # XXXX Optionally decode result
 348                 if _arguments.has_key('----'):
 349                         return _arguments['----']
 350
 351         def EndProgress(self, _object, _attributes={}, **_arguments):
 352                 """EndProgress: Nortifies the application that the progress indicator associated with TransactionID is no longer needed.
 353                 Required argument: TransactionID
 354                 Keyword argument _attributes: AppleEvent attribute dictionary
 355                 """
 356                 _code = 'WWW!'
 357                 _subcode = 'PREN'
 358
 359                 if _arguments: raise TypeError, 'No optional args expected'
 360                 _arguments['----'] = _object
 361
 362
 363                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 364                                 _arguments, _attributes)
 365                 if _arguments.has_key('errn'):
 366                         raise aetools.Error, aetools.decodeerror(_arguments)
 367                 # XXXX Optionally decode result
 368                 if _arguments.has_key('----'):
 369                         return _arguments['----']
 370
 371         def RegisterDone(self, _object, _attributes={}, **_arguments):
 372                 """RegisterDone: Signals that all processing initiated by the RegisteNow event associated by TransactionID has finished.
 373                 Required argument: TransactionID
 374                 Keyword argument _attributes: AppleEvent attribute dictionary
 375                 Returns: 0 = failure; 1 = success; 2 = sending application needs more time to complete operation.
 376                 """
 377                 _code = 'WWW!'
 378                 _subcode = 'RGDN'
 379
 380                 if _arguments: raise TypeError, 'No optional args expected'
 381                 _arguments['----'] = _object
 382
 383
 384                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 385                                 _arguments, _attributes)
 386                 if _arguments.has_key('errn'):
 387                         raise aetools.Error, aetools.decodeerror(_arguments)
 388                 # XXXX Optionally decode result
 389                 if _arguments.has_key('----'):
 390                         return _arguments['----']
 391
 392         _argmap_RegisterProtocol = {
 393                 '_for' : 'PROT',
 394         }
 395
 396         def RegisterProtocol(self, _object, _attributes={}, **_arguments):
 397                 """RegisterProtocol: Notifies that the sending application is able to handle all URLs for the specified protocol.
 398                 Required argument: application
 399                 Keyword argument _for: Protocol, such as NEWS, MAILTO, etc...
 400                 Keyword argument _attributes: AppleEvent attribute dictionary
 401                 Returns: Success
 402                 """
 403                 _code = 'WWW!'
 404                 _subcode = 'RGPR'
 405
 406                 aetools.keysubst(_arguments, self._argmap_RegisterProtocol)
 407                 _arguments['----'] = _object
 408
 409
 410                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 411                                 _arguments, _attributes)
 412                 if _arguments.has_key('errn'):
 413                         raise aetools.Error, aetools.decodeerror(_arguments)
 414                 # XXXX Optionally decode result
 415                 if _arguments.has_key('----'):
 416                         return _arguments['----']
 417
 418         _argmap_UnRegisterProtocol = {
 419                 '_for' : 'PROT',
 420         }
 421
 422         def UnRegisterProtocol(self, _object, _attributes={}, **_arguments):
 423                 """UnRegisterProtocol: Notifies that the sending application is no longer wishes to handle URLs for the specified protocol.
 424                 Required argument: application
 425                 Keyword argument _for: Protocol, such as NEWS, MAILTO, etc...
 426                 Keyword argument _attributes: AppleEvent attribute dictionary
 427                 """
 428                 _code = 'WWW!'
 429                 _subcode = 'UNRP'
 430
 431                 aetools.keysubst(_arguments, self._argmap_UnRegisterProtocol)
 432                 _arguments['----'] = _object
 433
 434
 435                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 436                                 _arguments, _attributes)
 437                 if _arguments.has_key('errn'):
 438                         raise aetools.Error, aetools.decodeerror(_arguments)
 439                 # XXXX Optionally decode result
 440                 if _arguments.has_key('----'):
 441                         return _arguments['----']
 442
 443         _argmap_RegisterViewer = {
 444                 '_for' : 'MIME',
 445                 'as' : 'FTYP',
 446                 'Flags' : 'MTHD',
 447         }
 448
 449         def RegisterViewer(self, _object, _attributes={}, **_arguments):
 450                 """RegisterViewer: Notifies that the sending application is able to handle all documents for the specified MIMEType.
 451                 Required argument: application
 452                 Keyword argument _for: MIMEType
 453                 Keyword argument as: File type for saved documents
 454                 Keyword argument Flags: undocumented, typecode 'shor'
 455                 Keyword argument _attributes: AppleEvent attribute dictionary
 456                 """
 457                 _code = 'WWW!'
 458                 _subcode = 'RGVW'
 459
 460                 aetools.keysubst(_arguments, self._argmap_RegisterViewer)
 461                 _arguments['----'] = _object
 462
 463
 464                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 465                                 _arguments, _attributes)
 466                 if _arguments.has_key('errn'):
 467                         raise aetools.Error, aetools.decodeerror(_arguments)
 468                 # XXXX Optionally decode result
 469                 if _arguments.has_key('----'):
 470                         return _arguments['----']
 471
 472         _argmap_UnRegisterViewer = {
 473                 '_for' : 'MIME',
 474         }
 475
 476         def UnRegisterViewer(self, _object, _attributes={}, **_arguments):
 477                 """UnRegisterViewer: Notifies that the sending application is no longer wishes to handle documents of the specified MIMEType.
 478                 Required argument: application
 479                 Keyword argument _for: MIMEType
 480                 Keyword argument _attributes: AppleEvent attribute dictionary
 481                 """
 482                 _code = 'WWW!'
 483                 _subcode = 'UNVW'
 484
 485                 aetools.keysubst(_arguments, self._argmap_UnRegisterViewer)
 486                 _arguments['----'] = _object
 487
 488
 489                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 490                                 _arguments, _attributes)
 491                 if _arguments.has_key('errn'):
 492                         raise aetools.Error, aetools.decodeerror(_arguments)
 493                 # XXXX Optionally decode result
 494                 if _arguments.has_key('----'):
 495                         return _arguments['----']
 496
 497         def RegisterURLEcho(self, _object, _attributes={}, **_arguments):
 498                 """RegisterURLEcho: Notifies that the sending application would like to receive EchoURL events.
 499                 Required argument: application
 500                 Keyword argument _attributes: AppleEvent attribute dictionary
 501                 Returns: Success
 502                 """
 503                 _code = 'WWW!'
 504                 _subcode = 'RGUE'
 505
 506                 if _arguments: raise TypeError, 'No optional args expected'
 507                 _arguments['----'] = _object
 508
 509
 510                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 511                                 _arguments, _attributes)
 512                 if _arguments.has_key('errn'):
 513                         raise aetools.Error, aetools.decodeerror(_arguments)
 514                 # XXXX Optionally decode result
 515                 if _arguments.has_key('----'):
 516                         return _arguments['----']
 517
 518         def UnRegisterURLEcho(self, _object, _attributes={}, **_arguments):
 519                 """UnRegisterURLEcho: Notifies that the sending application would no longer like to receive EchoURL events.
 520                 Required argument: application
 521                 Keyword argument _attributes: AppleEvent attribute dictionary
 522                 """
 523                 _code = 'WWW!'
 524                 _subcode = 'UNRU'
 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.has_key('errn'):
 533                         raise aetools.Error, aetools.decodeerror(_arguments)
 534                 # XXXX Optionally decode result
 535                 if _arguments.has_key('----'):
 536                         return _arguments['----']
 537
 538         def RegisterWindowClose(self, _object, _attributes={}, **_arguments):
 539                 """RegisterWindowClose: Notifies that the sending application would like to receive WindowClose events.
 540                 Required argument: application
 541                 Keyword argument _attributes: AppleEvent attribute dictionary
 542                 """
 543                 _code = 'WWW!'
 544                 _subcode = 'RGWC'
 545
 546                 if _arguments: raise TypeError, 'No optional args expected'
 547                 _arguments['----'] = _object
 548
 549
 550                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 551                                 _arguments, _attributes)
 552                 if _arguments.has_key('errn'):
 553                         raise aetools.Error, aetools.decodeerror(_arguments)
 554                 # XXXX Optionally decode result
 555                 if _arguments.has_key('----'):
 556                         return _arguments['----']
 557
 558         def UnRegisterWindowClose(self, _object, _attributes={}, **_arguments):
 559                 """UnRegisterWindowClose: Notifies that the sending application would no longer like to receive WindowClose events.
 560                 Required argument: application
 561                 Keyword argument _attributes: AppleEvent attribute dictionary
 562                 """
 563                 _code = 'WWW!'
 564                 _subcode = 'UNRC'
 565
 566                 if _arguments: raise TypeError, 'No optional args expected'
 567                 _arguments['----'] = _object
 568
 569
 570                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 571                                 _arguments, _attributes)
 572                 if _arguments.has_key('errn'):
 573                         raise aetools.Error, aetools.decodeerror(_arguments)
 574                 # XXXX Optionally decode result
 575                 if _arguments.has_key('----'):
 576                         return _arguments['----']
 577
 578         def RegisterAppClose(self, _object, _attributes={}, **_arguments):
 579                 """RegisterAppClose: Notifies that the sending application would like to receive AppClose events.
 580                 Required argument: application
 581                 Keyword argument _attributes: AppleEvent attribute dictionary
 582                 """
 583                 _code = 'WWW!'
 584                 _subcode = 'RGAC'
 585
 586                 if _arguments: raise TypeError, 'No optional args expected'
 587                 _arguments['----'] = _object
 588
 589
 590                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 591                                 _arguments, _attributes)
 592                 if _arguments.has_key('errn'):
 593                         raise aetools.Error, aetools.decodeerror(_arguments)
 594                 # XXXX Optionally decode result
 595                 if _arguments.has_key('----'):
 596                         return _arguments['----']
 597
 598         def UnRegisterAppClose(self, _object, _attributes={}, **_arguments):
 599                 """UnRegisterAppClose: Notifies that the sending application would no longer like to receive AppClose events.
 600                 Required argument: application
 601                 Keyword argument _attributes: AppleEvent attribute dictionary
 602                 """
 603                 _code = 'WWW!'
 604                 _subcode = 'UNRA'
 605
 606                 if _arguments: raise TypeError, 'No optional args expected'
 607                 _arguments['----'] = _object
 608
 609
 610                 _reply, _arguments, _attributes = self.send(_code, _subcode,
 611                                 _arguments, _attributes)
 612                 if _arguments.has_key('errn'):
 613                         raise aetools.Error, aetools.decodeerror(_arguments)
 614                 # XXXX Optionally decode result
 615                 if _arguments.has_key('----'):
 616                         return _arguments['----']
 617
 618
 619 #
 620 # Indices of types declared in this module
 621 #
 622 _classdeclarations = {
 623 }
 624
 625 _propdeclarations = {
 626 }
 627
 628 _compdeclarations = {
 629 }
 630
 631 _enumdeclarations = {
 632 }