l4/pkg/python/contrib/Lib/plat-mac/lib-scriptpackages/Netscape/WorldWideWeb_suite.py

   1 """Suite WorldWideWeb suite, as defined in Spyglass spec.:
   2 Level 1, version 1
   3
   4 Generated from /Volumes/Sap/Applications (Mac OS 9)/Netscape Communicator\xe2\x84\xa2 Folder/Netscape Communicator\xe2\x84\xa2
   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 WorldWideWeb_suite_Events:
  14
  15     _argmap_OpenURL = {
  16         'to' : 'INTO',
  17         'toWindow' : 'WIND',
  18         'flags' : 'FLGS',
  19         'post_data' : 'POST',
  20         'post_type' : 'MIME',
  21         'progressApp' : 'PROG',
  22     }
  23
  24     def OpenURL(self, _object, _attributes={}, **_arguments):
  25         """OpenURL: Opens a URL. Allows for more options than GetURL event
  26         Required argument: URL
  27         Keyword argument to: file destination
  28         Keyword argument toWindow: window iD
  29         Keyword argument flags: Binary: any combination of 1, 2 and 4 is allowed: 1 and 2 mean force reload the document. 4 is ignored
  30         Keyword argument post_data: Form posting data
  31         Keyword argument post_type: MIME type of the posting data. Defaults to application/x-www-form-urlencoded
  32         Keyword argument progressApp: Application that will display progress
  33         Keyword argument _attributes: AppleEvent attribute dictionary
  34         Returns: ID of the loading window
  35         """
  36         _code = 'WWW!'
  37         _subcode = 'OURL'
  38
  39         aetools.keysubst(_arguments, self._argmap_OpenURL)
  40         _arguments['----'] = _object
  41
  42
  43         _reply, _arguments, _attributes = self.send(_code, _subcode,
  44                 _arguments, _attributes)
  45         if _arguments.get('errn', 0):
  46             raise aetools.Error, aetools.decodeerror(_arguments)
  47         # XXXX Optionally decode result
  48         if _arguments.has_key('----'):
  49             return _arguments['----']
  50
  51     _argmap_ShowFile = {
  52         'MIME_type' : 'MIME',
  53         'Window_ID' : 'WIND',
  54         'URL' : 'URL ',
  55     }
  56
  57     def ShowFile(self, _object, _attributes={}, **_arguments):
  58         """ShowFile: Similar to OpenDocuments, except that it specifies the parent URL, and MIME type of the file
  59         Required argument: File to open
  60         Keyword argument MIME_type: MIME type
  61         Keyword argument Window_ID: Window to open the file in
  62         Keyword argument URL: Use this as a base URL
  63         Keyword argument _attributes: AppleEvent attribute dictionary
  64         Returns: Window ID of the loaded window. 0 means ShowFile failed, FFFFFFF means that data was not appropriate type to display in the browser.
  65         """
  66         _code = 'WWW!'
  67         _subcode = 'SHWF'
  68
  69         aetools.keysubst(_arguments, self._argmap_ShowFile)
  70         _arguments['----'] = _object
  71
  72
  73         _reply, _arguments, _attributes = self.send(_code, _subcode,
  74                 _arguments, _attributes)
  75         if _arguments.get('errn', 0):
  76             raise aetools.Error, aetools.decodeerror(_arguments)
  77         # XXXX Optionally decode result
  78         if _arguments.has_key('----'):
  79             return _arguments['----']
  80
  81     _argmap_cancel_progress = {
  82         'in_window' : 'WIND',
  83     }
  84
  85     def cancel_progress(self, _object=None, _attributes={}, **_arguments):
  86         """cancel progress: Interrupts the download of the document in the given window
  87         Required argument: progress ID, obtained from the progress app
  88         Keyword argument in_window: window ID of the progress to cancel
  89         Keyword argument _attributes: AppleEvent attribute dictionary
  90         """
  91         _code = 'WWW!'
  92         _subcode = 'CNCL'
  93
  94         aetools.keysubst(_arguments, self._argmap_cancel_progress)
  95         _arguments['----'] = _object
  96
  97
  98         _reply, _arguments, _attributes = self.send(_code, _subcode,
  99                 _arguments, _attributes)
 100         if _arguments.get('errn', 0):
 101             raise aetools.Error, aetools.decodeerror(_arguments)
 102         # XXXX Optionally decode result
 103         if _arguments.has_key('----'):
 104             return _arguments['----']
 105
 106     def find_URL(self, _object, _attributes={}, **_arguments):
 107         """find URL: If the file was downloaded by Netscape, you can call FindURL to find out the URL used to download the file.
 108         Required argument: File spec
 109         Keyword argument _attributes: AppleEvent attribute dictionary
 110         Returns: The URL
 111         """
 112         _code = 'WWW!'
 113         _subcode = 'FURL'
 114
 115         if _arguments: raise TypeError, 'No optional args expected'
 116         _arguments['----'] = _object
 117
 118
 119         _reply, _arguments, _attributes = self.send(_code, _subcode,
 120                 _arguments, _attributes)
 121         if _arguments.get('errn', 0):
 122             raise aetools.Error, aetools.decodeerror(_arguments)
 123         # XXXX Optionally decode result
 124         if _arguments.has_key('----'):
 125             return _arguments['----']
 126
 127     def get_window_info(self, _object=None, _attributes={}, **_arguments):
 128         """get window info: Returns the information about the window as a list. Currently the list contains the window title and the URL. You can get the same information using standard Apple Event GetProperty.
 129         Required argument: window ID
 130         Keyword argument _attributes: AppleEvent attribute dictionary
 131         Returns: undocumented, typecode 'list'
 132         """
 133         _code = 'WWW!'
 134         _subcode = 'WNFO'
 135
 136         if _arguments: raise TypeError, 'No optional args expected'
 137         _arguments['----'] = _object
 138
 139
 140         _reply, _arguments, _attributes = self.send(_code, _subcode,
 141                 _arguments, _attributes)
 142         if _arguments.get('errn', 0):
 143             raise aetools.Error, aetools.decodeerror(_arguments)
 144         # XXXX Optionally decode result
 145         if _arguments.has_key('----'):
 146             return _arguments['----']
 147
 148     def list_windows(self, _no_object=None, _attributes={}, **_arguments):
 149         """list windows: Lists the IDs of all the hypertext windows
 150         Keyword argument _attributes: AppleEvent attribute dictionary
 151         Returns: List of unique IDs of all the hypertext windows
 152         """
 153         _code = 'WWW!'
 154         _subcode = 'LSTW'
 155
 156         if _arguments: raise TypeError, 'No optional args expected'
 157         if _no_object is not None: raise TypeError, 'No direct arg expected'
 158
 159
 160         _reply, _arguments, _attributes = self.send(_code, _subcode,
 161                 _arguments, _attributes)
 162         if _arguments.get('errn', 0):
 163             raise aetools.Error, aetools.decodeerror(_arguments)
 164         # XXXX Optionally decode result
 165         if _arguments.has_key('----'):
 166             return _arguments['----']
 167
 168     _argmap_parse_anchor = {
 169         'relative_to' : 'RELA',
 170     }
 171
 172     def parse_anchor(self, _object, _attributes={}, **_arguments):
 173         """parse anchor: Resolves the relative URL
 174         Required argument: Main URL
 175         Keyword argument relative_to: Relative URL
 176         Keyword argument _attributes: AppleEvent attribute dictionary
 177         Returns: Parsed  URL
 178         """
 179         _code = 'WWW!'
 180         _subcode = 'PRSA'
 181
 182         aetools.keysubst(_arguments, self._argmap_parse_anchor)
 183         _arguments['----'] = _object
 184
 185
 186         _reply, _arguments, _attributes = self.send(_code, _subcode,
 187                 _arguments, _attributes)
 188         if _arguments.get('errn', 0):
 189             raise aetools.Error, aetools.decodeerror(_arguments)
 190         # XXXX Optionally decode result
 191         if _arguments.has_key('----'):
 192             return _arguments['----']
 193
 194     def register_URL_echo(self, _object=None, _attributes={}, **_arguments):
 195         """register URL echo: Registers the \xd2echo\xd3 application. Each download from now on will be echoed to this application.
 196         Required argument: Application signature
 197         Keyword argument _attributes: AppleEvent attribute dictionary
 198         """
 199         _code = 'WWW!'
 200         _subcode = 'RGUE'
 201
 202         if _arguments: raise TypeError, 'No optional args expected'
 203         _arguments['----'] = _object
 204
 205
 206         _reply, _arguments, _attributes = self.send(_code, _subcode,
 207                 _arguments, _attributes)
 208         if _arguments.get('errn', 0):
 209             raise aetools.Error, aetools.decodeerror(_arguments)
 210         # XXXX Optionally decode result
 211         if _arguments.has_key('----'):
 212             return _arguments['----']
 213
 214     _argmap_register_protocol = {
 215         'for_protocol' : 'PROT',
 216     }
 217
 218     def register_protocol(self, _object=None, _attributes={}, **_arguments):
 219         """register protocol: Registers application as a \xd2handler\xd3 for this protocol with a given prefix. The handler will receive \xd2OpenURL\xd3, or if that fails, \xd2GetURL\xd3 event.
 220         Required argument: Application sig
 221         Keyword argument for_protocol: protocol prefix: \xd2finger:\xd3, \xd2file\xd3,
 222         Keyword argument _attributes: AppleEvent attribute dictionary
 223         Returns: TRUE if registration has been successful
 224         """
 225         _code = 'WWW!'
 226         _subcode = 'RGPR'
 227
 228         aetools.keysubst(_arguments, self._argmap_register_protocol)
 229         _arguments['----'] = _object
 230
 231
 232         _reply, _arguments, _attributes = self.send(_code, _subcode,
 233                 _arguments, _attributes)
 234         if _arguments.get('errn', 0):
 235             raise aetools.Error, aetools.decodeerror(_arguments)
 236         # XXXX Optionally decode result
 237         if _arguments.has_key('----'):
 238             return _arguments['----']
 239
 240     _argmap_register_viewer = {
 241         'MIME_type' : 'MIME',
 242         'with_file_type' : 'FTYP',
 243     }
 244
 245     def register_viewer(self, _object, _attributes={}, **_arguments):
 246         """register viewer: Registers an application as a \xd4special\xd5 viewer for this MIME type. The application will be launched with ViewDoc events
 247         Required argument: Application sig
 248         Keyword argument MIME_type: MIME type viewer is registering for
 249         Keyword argument with_file_type: Mac file type for the downloaded files
 250         Keyword argument _attributes: AppleEvent attribute dictionary
 251         Returns: TRUE if registration has been successful
 252         """
 253         _code = 'WWW!'
 254         _subcode = 'RGVW'
 255
 256         aetools.keysubst(_arguments, self._argmap_register_viewer)
 257         _arguments['----'] = _object
 258
 259
 260         _reply, _arguments, _attributes = self.send(_code, _subcode,
 261                 _arguments, _attributes)
 262         if _arguments.get('errn', 0):
 263             raise aetools.Error, aetools.decodeerror(_arguments)
 264         # XXXX Optionally decode result
 265         if _arguments.has_key('----'):
 266             return _arguments['----']
 267
 268     _argmap_register_window_close = {
 269         'for_window' : 'WIND',
 270     }
 271
 272     def register_window_close(self, _object=None, _attributes={}, **_arguments):
 273         """register window close: Netscape will notify registered application when this window closes
 274         Required argument: Application signature
 275         Keyword argument for_window: window ID
 276         Keyword argument _attributes: AppleEvent attribute dictionary
 277         Returns: true if successful
 278         """
 279         _code = 'WWW!'
 280         _subcode = 'RGWC'
 281
 282         aetools.keysubst(_arguments, self._argmap_register_window_close)
 283         _arguments['----'] = _object
 284
 285
 286         _reply, _arguments, _attributes = self.send(_code, _subcode,
 287                 _arguments, _attributes)
 288         if _arguments.get('errn', 0):
 289             raise aetools.Error, aetools.decodeerror(_arguments)
 290         # XXXX Optionally decode result
 291         if _arguments.has_key('----'):
 292             return _arguments['----']
 293
 294     def unregister_URL_echo(self, _object, _attributes={}, **_arguments):
 295         """unregister URL echo: cancels URL echo
 296         Required argument: application signature
 297         Keyword argument _attributes: AppleEvent attribute dictionary
 298         """
 299         _code = 'WWW!'
 300         _subcode = 'UNRU'
 301
 302         if _arguments: raise TypeError, 'No optional args expected'
 303         _arguments['----'] = _object
 304
 305
 306         _reply, _arguments, _attributes = self.send(_code, _subcode,
 307                 _arguments, _attributes)
 308         if _arguments.get('errn', 0):
 309             raise aetools.Error, aetools.decodeerror(_arguments)
 310         # XXXX Optionally decode result
 311         if _arguments.has_key('----'):
 312             return _arguments['----']
 313
 314     _argmap_unregister_protocol = {
 315         'for_protocol' : 'PROT',
 316     }
 317
 318     def unregister_protocol(self, _object=None, _attributes={}, **_arguments):
 319         """unregister protocol: reverses the effects of \xd2register protocol\xd3
 320         Required argument: Application sig.
 321         Keyword argument for_protocol: protocol prefix. If none, unregister for all protocols
 322         Keyword argument _attributes: AppleEvent attribute dictionary
 323         Returns: TRUE if successful
 324         """
 325         _code = 'WWW!'
 326         _subcode = 'UNRP'
 327
 328         aetools.keysubst(_arguments, self._argmap_unregister_protocol)
 329         _arguments['----'] = _object
 330
 331
 332         _reply, _arguments, _attributes = self.send(_code, _subcode,
 333                 _arguments, _attributes)
 334         if _arguments.get('errn', 0):
 335             raise aetools.Error, aetools.decodeerror(_arguments)
 336         # XXXX Optionally decode result
 337         if _arguments.has_key('----'):
 338             return _arguments['----']
 339
 340     _argmap_unregister_viewer = {
 341         'MIME_type' : 'MIME',
 342     }
 343
 344     def unregister_viewer(self, _object, _attributes={}, **_arguments):
 345         """unregister viewer: Revert to the old way of handling this MIME type
 346         Required argument: Application sig
 347         Keyword argument MIME_type: MIME type to be unregistered
 348         Keyword argument _attributes: AppleEvent attribute dictionary
 349         Returns: TRUE if the event was successful
 350         """
 351         _code = 'WWW!'
 352         _subcode = 'UNRV'
 353
 354         aetools.keysubst(_arguments, self._argmap_unregister_viewer)
 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     _argmap_unregister_window_close = {
 367         'for_window' : 'WIND',
 368     }
 369
 370     def unregister_window_close(self, _object=None, _attributes={}, **_arguments):
 371         """unregister window close: Undo for register window close
 372         Required argument: Application signature
 373         Keyword argument for_window: window ID
 374         Keyword argument _attributes: AppleEvent attribute dictionary
 375         Returns: true if successful
 376         """
 377         _code = 'WWW!'
 378         _subcode = 'UNRC'
 379
 380         aetools.keysubst(_arguments, self._argmap_unregister_window_close)
 381         _arguments['----'] = _object
 382
 383
 384         _reply, _arguments, _attributes = self.send(_code, _subcode,
 385                 _arguments, _attributes)
 386         if _arguments.get('errn', 0):
 387             raise aetools.Error, aetools.decodeerror(_arguments)
 388         # XXXX Optionally decode result
 389         if _arguments.has_key('----'):
 390             return _arguments['----']
 391
 392     def webActivate(self, _object=None, _attributes={}, **_arguments):
 393         """webActivate: Makes Netscape the frontmost application, and selects a given window. This event is here for suite completeness/ cross-platform compatibility only, you should use standard AppleEvents instead.
 394         Required argument: window to bring to front
 395         Keyword argument _attributes: AppleEvent attribute dictionary
 396         """
 397         _code = 'WWW!'
 398         _subcode = 'ACTV'
 399
 400         if _arguments: raise TypeError, 'No optional args expected'
 401         _arguments['----'] = _object
 402
 403
 404         _reply, _arguments, _attributes = self.send(_code, _subcode,
 405                 _arguments, _attributes)
 406         if _arguments.get('errn', 0):
 407             raise aetools.Error, aetools.decodeerror(_arguments)
 408         # XXXX Optionally decode result
 409         if _arguments.has_key('----'):
 410             return _arguments['----']
 411
 412
 413 #
 414 # Indices of types declared in this module
 415 #
 416 _classdeclarations = {
 417 }
 418
 419 _propdeclarations = {
 420 }
 421
 422 _compdeclarations = {
 423 }
 424
 425 _enumdeclarations = {
 426 }