home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / xbmc-9.11.exe / system / python / spyce / modules / toc.py < prev    next >
Encoding:
Python Source  |  2009-12-23  |  7.1 KB  |  241 lines
  1. ##################################################
  2. # SPYCE - Python-based HTML Scripting
  3. # Copyright (c) 2002 Rimon Barr.
  4. #
  5. # Refer to spyce.py
  6. # CVS: $Id: toc.py 20864 2009-06-02 06:16:47Z ceros7 $
  7. ##################################################
  8.  
  9. from spyceModule import spyceModule
  10. import tree
  11.  
  12. __doc__ = '''Table-of-Contents module helps in creating indexed documents NB:
  13. The TOC module may force two passes of a file, if the first pass TOC emitted
  14. was not accurate. The second pass occurs via a redirect, so all modules are
  15. reinitialized. Unfortunately, this breaks things like include.context...'''
  16.  
  17. ROOT_NAME = 'root'
  18.  
  19. class toc(spyceModule):
  20.  
  21.   def start(self):
  22.     if not self._api.getModule('pool').has_key('toc'):
  23.       self._api.getModule('pool')['toc'] = {}
  24.     try:
  25.       self.oldtree, self.oldtags = self._api.getModule('pool')['toc'][self._api.getFilename()]
  26.     except (KeyError, TypeError):
  27.       self.oldtree = tree.tree( (ROOT_NAME, [], None) )
  28.       self.oldtags = {ROOT_NAME: self.oldtree}
  29.     # tree data: (tag, numbering, data)
  30.     self.tree = tree.tree((ROOT_NAME, [], None))
  31.     self.tags = {ROOT_NAME: self.tree}
  32.     self.node = self.tree
  33.     self.numbering = []
  34.     self.autotag = 0
  35.     self.tocShown = 0
  36.     self.fDOC_PUSH = None
  37.     self.fDOC_POP = None
  38.     self.fDOC_START = None
  39.     self.fDOC_END = None
  40.     self.fTOC_PUSH = None
  41.     self.fTOC_POP = None
  42.     self.fTOC_ENTRY = None
  43.   def finish(self, theError):
  44.     if not theError:
  45.       self.tree.computePreChain()
  46.       regenerate = not (self.oldtree == self.tree)
  47.       file = self._api.getFilename()
  48.       self._api.getModule('pool')['toc'][file] = self.tree, self.tags
  49.       self.oldtree.delete()
  50.       self.oldtree = None
  51.       self.oldtags = None
  52.       if self.tocShown and regenerate:
  53.         self._api.getModule('redirect').internal(file)
  54.  
  55.   # set callbacks
  56.   def setDOC_PUSH(self, f):
  57.     self.fDOC_PUSH = f
  58.   def setDOC_POP(self, f):
  59.     self.fDOC_POP = f
  60.   def setDOC_START(self, f):
  61.     self.fDOC_START = f
  62.   def setDOC_END(self, f):
  63.     self.fDOC_END = f
  64.   def setTOC_PUSH(self, f):
  65.     self.fTOC_PUSH = f
  66.   def setTOC_POP(self, f):
  67.     self.fTOC_POP = f
  68.   def setTOC_ENTRY(self, f):
  69.     self.fTOC_ENTRY = f
  70.  
  71.   # sectioning
  72.   def begin(self, data, tag=None, number=1):
  73.     self._emit(self.node, self.fDOC_PUSH)
  74.     self.numbering = _in(self.numbering)
  75.     if number: 
  76.       self.numbering = _inc(self.numbering)
  77.       self.node = self.node.append( (tag, self.numbering, data) )
  78.     else:
  79.       self.node = self.node.append( (tag, None, data) )
  80.     if not tag: tag = self._genTag()
  81.     self.tags[tag] = self.node
  82.     self._emit(self.node, self.fDOC_START)
  83.   def end(self):
  84.     self._emit(self.node, self.fDOC_END)
  85.     self.numbering = _out(self.numbering)
  86.     self.node = self.node.parent
  87.     self._emit(self.node, self.fDOC_POP)
  88.   def next(self, data, tag=None, number=1):
  89.     self._emit(self.node, self.fDOC_END)
  90.     self.node = self.node.parent
  91.     if number:
  92.       self.numbering = _inc(self.numbering)
  93.       self.node = self.node.append( (tag, self.numbering, data) )
  94.     else:
  95.       self.node = self.node.append( (tag, None, data) )
  96.     if not tag: tag = self._genTag()
  97.     self.tags[tag] = self.node
  98.     self._emit(self.node, self.fDOC_START)
  99.   def anchor(self, data, tag=ROOT_NAME):
  100.     self.tree.data = tag, [], data
  101.     self.tags[tag] = self.tree
  102.  
  103.   # shortcuts
  104.   b=begin
  105.   e=end
  106.   n=next
  107.  
  108.   # sectioning by depth
  109.   def level(self, depth, data, tag=None):
  110.     curdepth = self.getDepth()
  111.     if curdepth > depth:  # indent
  112.       while curdepth > depth:
  113.         self.end()
  114.         curdepth = self.getDepth()
  115.       self.next(data, tag)
  116.     elif curdepth < depth:  # outdent
  117.       while curdepth < depth - 1:
  118.         self.begin(None)
  119.         curdepth = self.getDepth()
  120.       self.begin(data, tag)
  121.     else: # next
  122.       self.next(data, tag)
  123.   def l1(self, data, tag=None):
  124.     self.level(1, data, tag)
  125.   def l2(self, data, tag=None):
  126.     self.level(2, data, tag)
  127.   def l3(self, data, tag=None):
  128.     self.level(3, data, tag)
  129.   def l4(self, data, tag=None):
  130.     self.level(4, data, tag)
  131.   def l5(self, data, tag=None):
  132.     self.level(5, data, tag)
  133.   def l6(self, data, tag=None):
  134.     self.level(6, data, tag)
  135.   def l7(self, data, tag=None):
  136.     self.level(7, data, tag)
  137.   def l8(self, data, tag=None):
  138.     self.level(8, data, tag)
  139.   def l9(self, data, tag=None):
  140.     self.level(9, data, tag)
  141.  
  142.   # show toc
  143.   def showTOC(self):
  144.     self.tocShown = 1
  145.     self._tocHelper(self.oldtree)
  146.   def _tocHelper(self, node):
  147.     self._emit(node, self.fTOC_ENTRY)
  148.     if node.children:
  149.       self._emit(node, self.fTOC_PUSH)
  150.       for c in node.children:
  151.         self._tocHelper(c)
  152.       self._emit(node, self.fTOC_POP)
  153.  
  154.   # current state
  155.   def getTag(self, node=None):
  156.     self.tocShown = 1
  157.     if not node: node = self.node
  158.     tag, numbering, data = node.data
  159.     return tag
  160.   def getNumbering(self, tag=None):
  161.     self.tocShown = 1
  162.     try:
  163.       node = self.node
  164.       if tag: node = self.oldtags[tag]
  165.       tag, numbering, data = node.data
  166.       return numbering
  167.     except KeyError:
  168.       return None
  169.   def getData(self, tag=None):
  170.     self.tocShown = 1
  171.     try:
  172.       node = self.node
  173.       if tag: node = self.oldtags[tag]
  174.       tag, numbering, data = node.data
  175.       return data
  176.     except KeyError:
  177.       return None
  178.   def getDepth(self, tag=None):
  179.     self.tocShown = 1
  180.     try:
  181.       node = self.node
  182.       if tag: node = self.tags[tag]
  183.       return node.depth
  184.     except KeyError:
  185.       return None
  186.   def getNextTag(self, tag=None):
  187.     self.tocShown = 1
  188.     try:
  189.       if not tag: tag = self.getTag()
  190.       tag = self.oldtags[tag].next
  191.       if tag==None: return None
  192.       return self.getTag(tag)
  193.     except KeyError:
  194.       return None
  195.   def getPrevTag(self, tag=None):
  196.     self.tocShown = 1
  197.     try:
  198.       if not tag: tag = self.getTag()
  199.       node = self.oldtags[tag].prev
  200.       if node==None: return None
  201.       return self.getTag(node)
  202.     except KeyError:
  203.       return None
  204.   def getParentTag(self, tag=None):
  205.     self.tocShown = 1
  206.     try:
  207.       if not tag: tag = self.getTag()
  208.       node = self.oldtags[tag].parent
  209.       if node==None: return None
  210.       return self.getTag(node)
  211.     except KeyError:
  212.       return None
  213.   def getChildrenTags(self, tag=None):
  214.     self.tocShown = 1
  215.     try:
  216.       if not tag: tag = self.getTag()
  217.       nodes = self.oldtags[tag].children
  218.       return map(self.getTag, nodes)
  219.     except KeyError:
  220.       return None
  221.  
  222.   # internal helpers
  223.   def _genTag(self):
  224.     tag = 'auto_'+str(self.autotag)
  225.     self.autotag = self.autotag + 1
  226.     return tag
  227.   def _emit(self, node, f):
  228.     tag, numbering, data = node.data
  229.     if f: s = f(node.depth, tag, numbering, data)
  230.  
  231. # hierarchical counting
  232. def _inc(numbering, inc=1):
  233.   return numbering[:-1]+[numbering[-1]+inc]
  234. def _in(numbering, start=0):
  235.   return numbering+[start]
  236. def _out(numbering):
  237.   return numbering[:-1]
  238.  
  239. def defaultOutput(tag, numbering, data):
  240.   return reduce(lambda s, i: '%s%d.' % (s, i), numbering, '') + ' ' + str(data)
  241.