Alternate fix for #728744: use OSA and Apple Help Indexing Tool's idleStatus

indicator to wait for the help indexing to finish.

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 = {
+}

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 = {
+}

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 = {
+}

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,
+}

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'
+

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 = {
+}

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)