def visit_compound(self, node):        pass    def depart_compound(self, node):        pass    def visit_contact(self, node):        self.visit_docinfo_item(node, 'contact')    def depart_contact(self, node):        self.depart_docinfo_item(node)    def visit_container(self, node):        pass    def depart_container(self, node):        pass    def visit_copyright(self, node):        self.visit_docinfo_item(node, 'copyright')    def depart_copyright(self, node):        self.depart_docinfo_item(node)    def visit_danger(self, node):        self.visit_admonition(node, 'danger')    def depart_danger(self, node):        self.depart_admonition()    def visit_date(self, node):        self.visit_docinfo_item(node, 'date')    def depart_date(self, node):        self.depart_docinfo_item(node)    def visit_decoration(self, node):        pass    def depart_decoration(self, node):        pass    def visit_definition(self, node):        self.body.append('%[visit_definition]\n')    def depart_definition(self, node):        self.body.append('\n')        self.body.append('%[depart_definition]\n')    def visit_definition_list(self, node):        self.body.append( '\\begin{description}\n' )    def depart_definition_list(self, node):        self.body.append( '\\end{description}\n' )    def visit_definition_list_item(self, node):        self.body.append('%[visit_definition_list_item]\n')    def depart_definition_list_item(self, node):        self.body.append('%[depart_definition_list_item]\n')    def visit_description(self, node):        if self.use_optionlist_for_option_list:            self.body.append( ' ' )        else:            self.body.append( ' & ' )    def depart_description(self, node):        pass    def visit_docinfo(self, node):        self.docinfo = []        self.docinfo.append('%' + '_'*75 + '\n')        self.docinfo.append('\\begin{center}\n')        self.docinfo.append('\\begin{tabularx}{\\docinfowidth}{lX}\n')    def depart_docinfo(self, node):        self.docinfo.append('\\end{tabularx}\n')        self.docinfo.append('\\end{center}\n')        self.body = self.docinfo + self.body        # clear docinfo, so field names are no longer appended.        self.docinfo = None    def visit_docinfo_item(self, node, name):        if name == 'author':            if not self.pdfinfo == None:                if not self.pdfauthor:                    self.pdfauthor = self.attval(node.astext())                else:                    self.pdfauthor += self.author_separator + self.attval(node.astext())        if self.use_latex_docinfo:            if name in ('author', 'organization', 'contact', 'address'):                # We attach these to the last author.  If any of them precedes                # the first author, put them in a separate "author" group (for                # no better semantics).                if name == 'author' or not self.author_stack:                    self.author_stack.append([])                if name == 'address':   # newlines are meaningful                    self.insert_newline = 1                    text = self.encode(node.astext())                    self.insert_newline = 0                else:                    text = self.attval(node.astext())                self.author_stack[-1].append(text)                raise nodes.SkipNode            elif name == 'date':                self.date = self.attval(node.astext())                raise nodes.SkipNode        self.docinfo.append('\\textbf{%s}: &\n\t' % self.language_label(name))        if name == 'address':            self.insert_newline = 1            self.docinfo.append('{\\raggedright\n')            self.context.append(' } \\\\\n')        else:            self.context.append(' \\\\\n')        self.context.append(self.docinfo)        self.context.append(len(self.body))    def depart_docinfo_item(self, node):        size = self.context.pop()        dest = self.context.pop()        tail = self.context.pop()        tail = self.body[size:] + [tail]        del self.body[size:]        dest.extend(tail)        # for address we did set insert_newline        self.insert_newline = 0    def visit_doctest_block(self, node):        self.body.append( '\\begin{verbatim}' )        self.verbatim = 1    def depart_doctest_block(self, node):        self.body.append( '\\end{verbatim}\n' )        self.verbatim = 0    def visit_document(self, node):        self.body_prefix.append('\\begin{document}\n')        # titled document?        if self.use_latex_docinfo or len(node) and isinstance(node[0], nodes.title):            self.body_prefix.append('\\maketitle\n\n')            # alternative use titlepage environment.            # \begin{titlepage}        self.body.append('\n\\setlength{\\locallinewidth}{\\linewidth}\n')    def depart_document(self, node):        # TODO insertion point of bibliography should none automatic.        if self._use_latex_citations and len(self._bibitems)>0:            widest_label = ""            for bi in self._bibitems:                if len(widest_label)<len(bi[0]):                    widest_label = bi[0]            self.body.append('\n\\begin{thebibliography}{%s}\n'%widest_label)            for bi in self._bibitems:                # cite_key: underscores must not be escaped                cite_key = bi[0].replace(r"{\_}","_")                self.body.append('\\bibitem[%s]{%s}{%s}\n' % (bi[0], cite_key, bi[1]))            self.body.append('\\end{thebibliography}\n')        self.body_suffix.append('\\end{document}\n')    def visit_emphasis(self, node):        self.body.append('\\emph{')        self.literal_block_stack.append('\\emph{')    def depart_emphasis(self, node):        self.body.append('}')        self.literal_block_stack.pop()    def visit_entry(self, node):        self.active_table.visit_entry()        # cell separation        if self.active_table.get_entry_number() == 1:            # if the firstrow is a multirow, this actually is the second row.            # this gets hairy if rowspans follow each other.            if self.active_table.get_rowspan(0):                count = 0                while self.active_table.get_rowspan(count):                    count += 1                    self.body.append(' & ')                self.active_table.visit_entry() # increment cell count        else:            self.body.append(' & ')        # multi{row,column}        # IN WORK BUG TODO HACK continues here        # multirow in LaTeX simply will enlarge the cell over several rows        # (the following n if n is positive, the former if negative).        if node.has_key('morerows') and node.has_key('morecols'):            raise NotImplementedError('Cells that '            'span multiple rows *and* columns are not supported, sorry.')        if node.has_key('morerows'):            count = node['morerows'] + 1            self.active_table.set_rowspan(self.active_table.get_entry_number()-1,count)            self.body.append('\\multirow{%d}{%s}{' % \                    (count,self.active_table.get_column_width()))            self.context.append('}')            # BUG following rows must have empty cells.        elif node.has_key('morecols'):            # the vertical bar before column is missing if it is the first column.            # the one after always.            if self.active_table.get_entry_number() == 1:                bar1 = self.active_table.get_vertical_bar()            else:                bar1 = ''            count = node['morecols'] + 1            self.body.append('\\multicolumn{%d}{%sl%s}{' % \                    (count, bar1, self.active_table.get_vertical_bar()))            self.context.append('}')        else:            self.context.append('')        # header / not header        if isinstance(node.parent.parent, nodes.thead):            self.body.append('\\textbf{')            self.context.append('}')        else:            self.context.append('')    def depart_entry(self, node):        self.body.append(self.context.pop()) # header / not header        self.body.append(self.context.pop()) # multirow/column        # if following row is spanned from above.        if self.active_table.get_rowspan(self.active_table.get_entry_number()):           self.body.append(' & ')           self.active_table.visit_entry() # increment cell count    def visit_row(self, node):        self.active_table.visit_row()    def depart_row(self, node):        self.body.extend(self.active_table.depart_row())    def visit_enumerated_list(self, node):        # We create our own enumeration list environment.        # This allows to set the style and starting value        # and unlimited nesting.        self._enum_cnt += 1        enum_style = {'arabic':'arabic',                'loweralpha':'alph',                'upperalpha':'Alph',                'lowerroman':'roman',                'upperroman':'Roman' }        enum_suffix = ""        if node.has_key('suffix'):            enum_suffix = node['suffix']        enum_prefix = ""        if node.has_key('prefix'):            enum_prefix = node['prefix']        if self.compound_enumerators:            pref = ""            if self.section_prefix_for_enumerators and self.section_level:                for i in range(self.section_level):                    pref += '%d.' % self._section_number[i]                pref = pref[:-1] + self.section_enumerator_separator                enum_prefix += pref            for counter in self._enumeration_counters:                enum_prefix += counter + '.'        enum_type = "arabic"        if node.has_key('enumtype'):            enum_type = node['enumtype']        if enum_style.has_key(enum_type):            enum_type = enum_style[enum_type]        counter_name = "listcnt%d" % self._enum_cnt;        self._enumeration_counters.append("\\%s{%s}" % (enum_type,counter_name))        self.body.append('\\newcounter{%s}\n' % counter_name)        self.body.append('\\begin{list}{%s\\%s{%s}%s}\n' % \            (enum_prefix,enum_type,counter_name,enum_suffix))        self.body.append('{\n')        self.body.append('\\usecounter{%s}\n' % counter_name)        # set start after usecounter, because it initializes to zero.        if node.has_key('start'):            self.body.append('\\addtocounter{%s}{%d}\n' \                    % (counter_name,node['start']-1))        ## set rightmargin equal to leftmargin        self.body.append('\\setlength{\\rightmargin}{\\leftmargin}\n')        self.body.append('}\n')    def depart_enumerated_list(self, node):        self.body.append('\\end{list}\n')        self._enumeration_counters.pop()    def visit_error(self, node):        self.visit_admonition(node, 'error')    def depart_error(self, node):        self.depart_admonition()    def visit_field(self, node):        # real output is done in siblings: _argument, _body, _name        pass    def depart_field(self, node):        self.body.append('\n')        ##self.body.append('%[depart_field]\n')    def visit_field_argument(self, node):        self.body.append('%[visit_field_argument]\n')    def depart_field_argument(self, node):        self.body.append('%[depart_field_argument]\n')    def visit_field_body(self, node):        # BUG by attach as text we loose references.        if self.docinfo:            self.docinfo.append('%s \\\\\n' % self.encode(node.astext()))            raise nodes.SkipNode        # BUG: what happens if not docinfo    def depart_field_body(self, node):        self.body.append( '\n' )    def visit_field_list(self, node):        if not self.docinfo:            self.body.append('\\begin{quote}\n')            self.body.append('\\begin{description}\n')    def depart_field_list(self, node):        if not self.docinfo:            self.body.append('\\end{description}\n')            self.body.append('\\end{quote}\n')    def visit_field_name(self, node):        # BUG this duplicates docinfo_item        if self.docinfo:            self.docinfo.append('\\textbf{%s}: &\n\t' % self.encode(node.astext()))            raise nodes.SkipNode        else:            self.body.append('\\item [')    def depart_field_name(self, node):        if not self.docinfo:            self.body.append(':]')    def visit_figure(self, node):        if not node.attributes.has_key('align'):            align = 'center'        else:            align = 'flush'+node.attributes['align']        self.body.append( '\\begin{figure}[htbp]\\begin{%s}\n' % align )        self.context.append( '\\end{%s}\\end{figure}\n' % align )    def depart_figure(self, node):        self.body.append( self.context.pop() )    def visit_footer(self, node):        self.context.append(len(self.body))