From f7c822073e8b0b899343e2f222778ff1eb37b2c6 Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Tue, 27 May 2003 22:47:55 +0000 Subject: [PATCH] Alternate fix for #728744: use OSA and Apple Help Indexing Tool's idleStatus indicator to wait for the help indexing to finish. --- .../Help_Indexing_Tool_Suite.py | 110 ++++++ .../Miscellaneous_Standards.py | 49 +++ .../Doc/HelpIndexingTool/Required_Suite.py | 32 ++ .../Doc/HelpIndexingTool/Standard_Suite.py | 343 ++++++++++++++++++ Mac/OSX/Doc/HelpIndexingTool/__init__.py | 79 ++++ Mac/OSX/Doc/HelpIndexingTool/odds_and_ends.py | 49 +++ Mac/OSX/Doc/setup.py | 25 +- 7 files changed, 686 insertions(+), 1 deletion(-) create mode 100644 Mac/OSX/Doc/HelpIndexingTool/Help_Indexing_Tool_Suite.py create mode 100644 Mac/OSX/Doc/HelpIndexingTool/Miscellaneous_Standards.py create mode 100644 Mac/OSX/Doc/HelpIndexingTool/Required_Suite.py create mode 100644 Mac/OSX/Doc/HelpIndexingTool/Standard_Suite.py create mode 100644 Mac/OSX/Doc/HelpIndexingTool/__init__.py create mode 100644 Mac/OSX/Doc/HelpIndexingTool/odds_and_ends.py diff --git a/Mac/OSX/Doc/HelpIndexingTool/Help_Indexing_Tool_Suite.py b/Mac/OSX/Doc/HelpIndexingTool/Help_Indexing_Tool_Suite.py new file mode 100644 index 00000000000..58d73076dfb --- /dev/null +++ b/Mac/OSX/Doc/HelpIndexingTool/Help_Indexing_Tool_Suite.py @@ -0,0 +1,110 @@ +"""Suite Help Indexing Tool Suite: Special events that just the Help Indexing Tool supports. +Level 0, version 0 + +Generated from /Developer/Applications/Apple Help Indexing Tool.app +AETE/AEUT resource version 1/1, language 0, script 0 +""" + +import aetools +import MacOS + +_code = 'HIT ' + +class Help_Indexing_Tool_Suite_Events: + + def turn_anchor_indexing(self, _object, _attributes={}, **_arguments): + """turn anchor indexing: Turns anchor indexing on or off. + Required argument: \xd2on\xd3 or \xd2off\xd3, to turn anchor indexing on or off + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'HIT ' + _subcode = 'tAnc' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + _argmap_turn_remote_root = { + 'with_root_url' : 'rURL', + } + + def turn_remote_root(self, _object, _attributes={}, **_arguments): + """turn remote root: Turn usage of remote root for content on the web on or off. If turning \xd2on\xd3, supply a string as second parameter. + Required argument: \xd2on\xd3 or \xd2off\xd3, to turn remote root on or off + Keyword argument with_root_url: The remote root to use, in the form of \xd2http://www.apple.com/help/\xd3. + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'HIT ' + _subcode = 'tRem' + + aetools.keysubst(_arguments, self._argmap_turn_remote_root) + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + def use_tokenizer(self, _object, _attributes={}, **_arguments): + """use tokenizer: Tells the indexing tool which tokenizer to use. + Required argument: Specify \xd2English\xd3, \xd2European\xd3, \xd2Japanese\xd3, \xd2Korean\xd3, or \xd2Simple\xd3. + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'HIT ' + _subcode = 'uTok' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + +class application(aetools.ComponentItem): + """application - Application class """ + want = 'capp' +class _Prop_idleStatus(aetools.NProperty): + """idleStatus - """ + which = 'sIdl' + want = 'bool' +application._superclassnames = [] +application._privpropdict = { + 'idleStatus' : _Prop_idleStatus, +} +application._privelemdict = { +} + +# +# Indices of types declared in this module +# +_classdeclarations = { + 'capp' : application, +} + +_propdeclarations = { + 'sIdl' : _Prop_idleStatus, +} + +_compdeclarations = { +} + +_enumdeclarations = { +} diff --git a/Mac/OSX/Doc/HelpIndexingTool/Miscellaneous_Standards.py b/Mac/OSX/Doc/HelpIndexingTool/Miscellaneous_Standards.py new file mode 100644 index 00000000000..3cf745f9860 --- /dev/null +++ b/Mac/OSX/Doc/HelpIndexingTool/Miscellaneous_Standards.py @@ -0,0 +1,49 @@ +"""Suite Miscellaneous Standards: Useful events that aren\xd5t in any other suite +Level 0, version 0 + +Generated from /Developer/Applications/Apple Help Indexing Tool.app +AETE/AEUT resource version 1/1, language 0, script 0 +""" + +import aetools +import MacOS + +_code = 'misc' + +class Miscellaneous_Standards_Events: + + def revert(self, _object, _attributes={}, **_arguments): + """revert: Revert an object to the most recently saved version + Required argument: object to revert + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'misc' + _subcode = 'rvrt' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + +# +# Indices of types declared in this module +# +_classdeclarations = { +} + +_propdeclarations = { +} + +_compdeclarations = { +} + +_enumdeclarations = { +} diff --git a/Mac/OSX/Doc/HelpIndexingTool/Required_Suite.py b/Mac/OSX/Doc/HelpIndexingTool/Required_Suite.py new file mode 100644 index 00000000000..eb9fee00172 --- /dev/null +++ b/Mac/OSX/Doc/HelpIndexingTool/Required_Suite.py @@ -0,0 +1,32 @@ +"""Suite Required Suite: Terms that every application should support +Level 1, version 1 + +Generated from /Developer/Applications/Apple Help Indexing Tool.app +AETE/AEUT resource version 1/1, language 0, script 0 +""" + +import aetools +import MacOS + +_code = 'reqd' + +from StdSuites.Required_Suite import * +class Required_Suite_Events(Required_Suite_Events): + + pass + + +# +# Indices of types declared in this module +# +_classdeclarations = { +} + +_propdeclarations = { +} + +_compdeclarations = { +} + +_enumdeclarations = { +} diff --git a/Mac/OSX/Doc/HelpIndexingTool/Standard_Suite.py b/Mac/OSX/Doc/HelpIndexingTool/Standard_Suite.py new file mode 100644 index 00000000000..e986d753c95 --- /dev/null +++ b/Mac/OSX/Doc/HelpIndexingTool/Standard_Suite.py @@ -0,0 +1,343 @@ +"""Suite Standard Suite: Common terms for most applications +Level 1, version 1 + +Generated from /Developer/Applications/Apple Help Indexing Tool.app +AETE/AEUT resource version 1/1, language 0, script 0 +""" + +import aetools +import MacOS + +_code = 'CoRe' + +from StdSuites.Standard_Suite import * +class Standard_Suite_Events(Standard_Suite_Events): + + _argmap_close = { + 'saving' : 'savo', + 'in_' : 'kfil', + } + + def close(self, _object, _attributes={}, **_arguments): + """close: Close an object + Required argument: the objects to close + Keyword argument saving: specifies whether or not changes should be saved before closing + Keyword argument in_: the file in which to save the object + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'core' + _subcode = 'clos' + + aetools.keysubst(_arguments, self._argmap_close) + _arguments['----'] = _object + + aetools.enumsubst(_arguments, 'savo', _Enum_savo) + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + def data_size(self, _object, _attributes={}, **_arguments): + """data size: Return the size in bytes of an object + Required argument: the object whose data size is to be returned + Keyword argument _attributes: AppleEvent attribute dictionary + Returns: the size of the object in bytes + """ + _code = 'core' + _subcode = 'dsiz' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + def get(self, _object, _attributes={}, **_arguments): + """get: Get the data for an object + Required argument: the object whose data is to be returned + Keyword argument _attributes: AppleEvent attribute dictionary + Returns: The data from the object + """ + _code = 'core' + _subcode = 'getd' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + _argmap_make = { + 'new' : 'kocl', + 'at' : 'insh', + 'with_data' : 'data', + 'with_properties' : 'prdt', + } + + def make(self, _no_object=None, _attributes={}, **_arguments): + """make: Make a new element + Keyword argument new: the class of the new element + Keyword argument at: the location at which to insert the element + Keyword argument with_data: the initial data for the element + Keyword argument with_properties: the initial values for the properties of the element + Keyword argument _attributes: AppleEvent attribute dictionary + Returns: Object specifier for the new element + """ + _code = 'core' + _subcode = 'crel' + + aetools.keysubst(_arguments, self._argmap_make) + if _no_object != None: raise TypeError, 'No direct arg expected' + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + def open(self, _object, _attributes={}, **_arguments): + """open: Open the specified object(s) + Required argument: Objects to open. Can be a list of files or an object specifier. + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'aevt' + _subcode = 'odoc' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + def print_(self, _object, _attributes={}, **_arguments): + """print: Print the specified object(s) + Required argument: Objects to print. Can be a list of files or an object specifier. + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'aevt' + _subcode = 'pdoc' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + _argmap_save = { + 'in_' : 'kfil', + 'as' : 'fltp', + } + + def save(self, _object, _attributes={}, **_arguments): + """save: save a set of objects + Required argument: Objects to save. + Keyword argument in_: the file in which to save the object(s) + Keyword argument as: the file type of the document in which to save the data + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'core' + _subcode = 'save' + + aetools.keysubst(_arguments, self._argmap_save) + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + _argmap_set = { + 'to' : 'data', + } + + def set(self, _object, _attributes={}, **_arguments): + """set: Set an object\xd5s data + Required argument: the object to change + Keyword argument to: the new value + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'core' + _subcode = 'setd' + + aetools.keysubst(_arguments, self._argmap_set) + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + +class application(aetools.ComponentItem): + """application - An application program """ + want = 'capp' +# element 'cwin' as ['indx', 'name', 'rele'] +# element 'docu' as ['name'] + +class window(aetools.ComponentItem): + """window - A Window """ + want = 'cwin' +class _Prop_bounds(aetools.NProperty): + """bounds - the boundary rectangle for the window """ + which = 'pbnd' + want = 'qdrt' +class _Prop_closeable(aetools.NProperty): + """closeable - Does the window have a close box? """ + which = 'hclb' + want = 'bool' +class _Prop_floating(aetools.NProperty): + """floating - Does the window float? """ + which = 'isfl' + want = 'bool' +class _Prop_index(aetools.NProperty): + """index - the number of the window """ + which = 'pidx' + want = 'long' +class _Prop_modal(aetools.NProperty): + """modal - Is the window modal? """ + which = 'pmod' + want = 'bool' +class _Prop_name(aetools.NProperty): + """name - the title of the window """ + which = 'pnam' + want = 'itxt' +class _Prop_position(aetools.NProperty): + """position - upper left coordinates of window """ + which = 'ppos' + want = 'QDpt' +class _Prop_resizable(aetools.NProperty): + """resizable - Is the window resizable? """ + which = 'prsz' + want = 'bool' +class _Prop_titled(aetools.NProperty): + """titled - Does the window have a title bar? """ + which = 'ptit' + want = 'bool' +class _Prop_visible(aetools.NProperty): + """visible - is the window visible? """ + which = 'pvis' + want = 'bool' +class _Prop_zoomable(aetools.NProperty): + """zoomable - Is the window zoomable? """ + which = 'iszm' + want = 'bool' +class _Prop_zoomed(aetools.NProperty): + """zoomed - Is the window zoomed? """ + which = 'pzum' + want = 'bool' + +class document(aetools.ComponentItem): + """document - A Document """ + want = 'docu' +class _Prop_modified(aetools.NProperty): + """modified - Has the document been modified since the last save? """ + which = 'imod' + want = 'bool' +application._superclassnames = [] +application._privpropdict = { +} +application._privelemdict = { + 'document' : document, + 'window' : window, +} +window._superclassnames = [] +window._privpropdict = { + 'bounds' : _Prop_bounds, + 'closeable' : _Prop_closeable, + 'floating' : _Prop_floating, + 'index' : _Prop_index, + 'modal' : _Prop_modal, + 'name' : _Prop_name, + 'position' : _Prop_position, + 'resizable' : _Prop_resizable, + 'titled' : _Prop_titled, + 'visible' : _Prop_visible, + 'zoomable' : _Prop_zoomable, + 'zoomed' : _Prop_zoomed, +} +window._privelemdict = { +} +document._superclassnames = [] +document._privpropdict = { + 'modified' : _Prop_modified, + 'name' : _Prop_name, +} +document._privelemdict = { +} +_Enum_savo = { + 'yes' : 'yes ', # Save objects now + 'no' : 'no ', # Do not save objects + 'ask' : 'ask ', # Ask the user whether to save +} + + +# +# Indices of types declared in this module +# +_classdeclarations = { + 'capp' : application, + 'cwin' : window, + 'docu' : document, +} + +_propdeclarations = { + 'hclb' : _Prop_closeable, + 'imod' : _Prop_modified, + 'isfl' : _Prop_floating, + 'iszm' : _Prop_zoomable, + 'pbnd' : _Prop_bounds, + 'pidx' : _Prop_index, + 'pmod' : _Prop_modal, + 'pnam' : _Prop_name, + 'ppos' : _Prop_position, + 'prsz' : _Prop_resizable, + 'ptit' : _Prop_titled, + 'pvis' : _Prop_visible, + 'pzum' : _Prop_zoomed, +} + +_compdeclarations = { +} + +_enumdeclarations = { + 'savo' : _Enum_savo, +} diff --git a/Mac/OSX/Doc/HelpIndexingTool/__init__.py b/Mac/OSX/Doc/HelpIndexingTool/__init__.py new file mode 100644 index 00000000000..2745086b485 --- /dev/null +++ b/Mac/OSX/Doc/HelpIndexingTool/__init__.py @@ -0,0 +1,79 @@ +""" +Package generated from /Developer/Applications/Apple Help Indexing Tool.app +""" +import aetools +Error = aetools.Error +import Standard_Suite +import Help_Indexing_Tool_Suite +import odds_and_ends +import Miscellaneous_Standards +import Required_Suite + + +_code_to_module = { + 'CoRe' : Standard_Suite, + 'HIT ' : Help_Indexing_Tool_Suite, + 'Odds' : odds_and_ends, + 'misc' : Miscellaneous_Standards, + 'reqd' : Required_Suite, +} + + + +_code_to_fullname = { + 'CoRe' : ('HelpIndexingTool.Standard_Suite', 'Standard_Suite'), + 'HIT ' : ('HelpIndexingTool.Help_Indexing_Tool_Suite', 'Help_Indexing_Tool_Suite'), + 'Odds' : ('HelpIndexingTool.odds_and_ends', 'odds_and_ends'), + 'misc' : ('HelpIndexingTool.Miscellaneous_Standards', 'Miscellaneous_Standards'), + 'reqd' : ('HelpIndexingTool.Required_Suite', 'Required_Suite'), +} + +from Standard_Suite import * +from Help_Indexing_Tool_Suite import * +from odds_and_ends import * +from Miscellaneous_Standards import * +from Required_Suite import * + +def getbaseclasses(v): + if not getattr(v, '_propdict', None): + v._propdict = {} + v._elemdict = {} + for superclassname in getattr(v, '_superclassnames', []): + superclass = eval(superclassname) + getbaseclasses(superclass) + v._propdict.update(getattr(superclass, '_propdict', {})) + v._elemdict.update(getattr(superclass, '_elemdict', {})) + v._propdict.update(getattr(v, '_privpropdict', {})) + v._elemdict.update(getattr(v, '_privelemdict', {})) + +import StdSuites + +# +# Set property and element dictionaries now that all classes have been defined +# +getbaseclasses(window) +getbaseclasses(application) +getbaseclasses(document) +getbaseclasses(application) + +# +# Indices of types declared in this module +# +_classdeclarations = { + 'cwin' : window, + 'capp' : application, + 'docu' : document, + 'capp' : application, +} + + +class HelpIndexingTool(Standard_Suite_Events, + Help_Indexing_Tool_Suite_Events, + odds_and_ends_Events, + Miscellaneous_Standards_Events, + Required_Suite_Events, + aetools.TalkTo): + _signature = 'hiti' + + _moduleName = 'HelpIndexingTool' + diff --git a/Mac/OSX/Doc/HelpIndexingTool/odds_and_ends.py b/Mac/OSX/Doc/HelpIndexingTool/odds_and_ends.py new file mode 100644 index 00000000000..7ee46f35cc2 --- /dev/null +++ b/Mac/OSX/Doc/HelpIndexingTool/odds_and_ends.py @@ -0,0 +1,49 @@ +"""Suite odds and ends: Things that should be in some standard suite, but aren\xd5t +Level 1, version 1 + +Generated from /Developer/Applications/Apple Help Indexing Tool.app +AETE/AEUT resource version 1/1, language 0, script 0 +""" + +import aetools +import MacOS + +_code = 'Odds' + +class odds_and_ends_Events: + + def select(self, _object=None, _attributes={}, **_arguments): + """select: Select the specified object + Required argument: the object to select + Keyword argument _attributes: AppleEvent attribute dictionary + """ + _code = 'misc' + _subcode = 'slct' + + if _arguments: raise TypeError, 'No optional args expected' + _arguments['----'] = _object + + + _reply, _arguments, _attributes = self.send(_code, _subcode, + _arguments, _attributes) + if _arguments.get('errn', 0): + raise aetools.Error, aetools.decodeerror(_arguments) + # XXXX Optionally decode result + if _arguments.has_key('----'): + return _arguments['----'] + + +# +# Indices of types declared in this module +# +_classdeclarations = { +} + +_propdeclarations = { +} + +_compdeclarations = { +} + +_enumdeclarations = { +} diff --git a/Mac/OSX/Doc/setup.py b/Mac/OSX/Doc/setup.py index 7ab0ea97074..9940568c3be 100644 --- a/Mac/OSX/Doc/setup.py +++ b/Mac/OSX/Doc/setup.py @@ -24,8 +24,10 @@ from distutils.log import log from distutils.spawn import spawn from distutils import sysconfig, dep_util from distutils.util import change_root +import HelpIndexingTool +import Carbon.File +import time - class DocBuild(build): def initialize_options(self): build.initialize_options(self) @@ -112,6 +114,27 @@ class DocBuild(build): self.spawn('open', '-a', app , self.build_dest) print "Please wait until Apple Help Indexing Tool finishes before installing" + def makeHelpIndex(self): + app = HelpIndexingTool.HelpIndexingTool(start=1) + app.open(Carbon.File.FSSpec(self.build_dest)) + sys.stderr.write("Waiting for Help Indexing Tool to start...") + while 1: + # This is bad design in the suite generation code! + idle = app._get(HelpIndexingTool.Help_Indexing_Tool_Suite._Prop_idleStatus()) + time.sleep(10) + if not idle: break + sys.stderr.write(".") + sys.stderr.write("\n") + sys.stderr.write("Waiting for Help Indexing Tool to finish...") + while 1: + # This is bad design in the suite generation code! + idle = app._get(HelpIndexingTool.Help_Indexing_Tool_Suite._Prop_idleStatus()) + time.sleep(10) + if idle: break + sys.stderr.write(".") + sys.stderr.write("\n") + + def run(self): self.ensure_finalized() self.mkpath(self.build_base)