diff options
Diffstat (limited to 'presentty/rst.py')
| -rw-r--r-- | presentty/rst.py | 493 |
1 files changed, 493 insertions, 0 deletions
diff --git a/presentty/rst.py b/presentty/rst.py new file mode 100644 index 0000000..41b3f97 --- /dev/null +++ b/presentty/rst.py @@ -0,0 +1,493 @@ +# Copyright (C) 2015 James E. Blair <corvus@gnu.org> +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +import os +import re +import docutils +import docutils.frontend +import docutils.parsers.rst +import docutils.nodes +import cStringIO as StringIO + +import urwid + +import slide +import transition as transition_mod +import image +import ansiparser +import text + +try: + import PIL + import PIL.Image +except ImportError: + PIL = None + +DEFAULT_TRANSITION = 'dissolve' +DEFAULT_TRANSITION_DURATION = 0.4 + +class TextAccumulator(object): + def __init__(self): + self.text = [] + + def append(self, text): + self.text.append(text) + + def getFormattedText(self): + return self.text + + wsre = re.compile('\s+') + + def getFlowedText(self): + ret = [] + for part in self.text: + if isinstance(part, tuple): + ret.append((part[0], self.wsre.sub(u' ', part[1]))) + else: + ret.append(self.wsre.sub(u' ', part)) + if not ret: + return u'' + return ret + +class UrwidTranslator(docutils.nodes.GenericNodeVisitor): + transition_map = {'dissolve': transition_mod.DissolveTransition, + 'cut': transition_mod.CutTransition, + 'pan': transition_mod.PanTransition, + } + + def __init__(self, document, palette, hinter=None, basedir='.'): + docutils.nodes.GenericNodeVisitor.__init__(self, document) + self.program = [] + self.stack = [] + self.default_transition = self._make_transition( + DEFAULT_TRANSITION, + DEFAULT_TRANSITION_DURATION) + self.transition = self.default_transition + self.attr = [] + self.table_columns = [] + self.table_column = [] + self.progressives = [] + self.palette = palette + self.hinter = hinter + self.basedir = basedir + self.slide = None + self.default_hide_title = False + self.hide_title = self.default_hide_title + + def _make_transition(self, name, duration): + tr = self.transition_map[name] + return tr(duration) + + def default_visit(self, node): + """Override for generic, uniform traversals.""" + pass + + def default_departure(self, node): + """Override for generic, uniform traversals.""" + pass + + def _append(self, node, widget, *args, **kw): + if self.stack: + if 'handout' in node.get('classes'): + if self.handout_pile not in self.stack: + container = self.handout_pile + else: + # If the handout pile is in the stack, then ignore + # this class -- it has probably needlessly been + # applied to something deeper in the stack. The + # thing further up will end up in the handout. + container = self.stack[-1] + else: + container = self.stack[-1] + container.contents.append((widget, container.options(*args, **kw))) + + def styled(self, style, text): + if style in self.palette: + return (self.palette[style], text) + return text + + def visit_transition(self, node): + name = node['name'] + duration = node.get('duration', DEFAULT_TRANSITION_DURATION) + self.transition = self._make_transition(name, duration) + + def depart_transition(self, node): + pass + + def visit_hidetitle(self, node): + if self.slide: + self.hide_title = True + else: + self.default_hide_title = True + + def depart_hidetitle(self, node): + pass + + def visit_system_message(self, node): + #print node.astext() + raise docutils.nodes.SkipNode() + + def visit_section(self, node): + self.hide_title = self.default_hide_title + self.transition = self.default_transition + title_pile = slide.SlidePile([]) + title_pad = slide.SlidePadding(title_pile, + align='center', width='pack') + + main_pile = slide.SlidePile([]) + main_pad = slide.SlidePadding(main_pile, align='center', width='pack') + outer_pile = slide.SlidePile([ + ('pack', title_pad), + ('pack', main_pad), + ]) + s = slide.UrwidSlide(u'', self.transition, outer_pile, + self.palette['_default']) + self.slide = s + self.stack.append(main_pile) + self.title_pile = title_pile + + pile = slide.SlidePile([]) + s = slide.Handout(pile, self.palette['_default']) + self.handout = s + self.handout_pile = pile + self.slide.handout = s + + def depart_section(self, node): + self.slide.transition = self.transition + if self.hide_title: + self.title_pile.contents[:] = [] + self.program.append(self.slide) + self.stack.pop() + + def visit_block_quote(self, node): + self.stack.append(slide.SlidePile([])) + + def depart_block_quote(self, node): + pile = self.stack.pop() + pad = slide.SlidePadding(pile, left=2) + self._append(node, pad, 'pack') + + def visit_list_item(self, node): + self.stack.append(slide.SlidePile([])) + + def depart_list_item(self, node): + pile = self.stack.pop() + bullet = urwid.Text(u'* ') + cols = slide.SlideColumns([]) + cols.contents.append((bullet, cols.options('pack'))) + cols.contents.append((pile, cols.options('weight', 1))) + if self.progressives: + cols = urwid.AttrMap(cols, self.palette['progressive']) + self.progressives[-1].append(cols) + self._append(node, cols, 'pack') + + def visit_tgroup(self, node): + self.table_columns.append([]) + self.stack.append(slide.SlidePile([])) + + def visit_colspec(self, node): + self.table_columns[-1].append(node['colwidth']) + + def visit_row(self, node): + self.stack.append(slide.SlideColumns([], dividechars=1)) + self.table_column.append(0) + + def depart_row(self, node): + self.table_column.pop() + cols = self.stack.pop() + self._append(node, cols, 'pack') + + def visit_thead(self, node): + pass + + def depart_thead(self, node): + cols = slide.SlideColumns([], dividechars=1) + for width in self.table_columns[-1]: + cols.contents.append((urwid.Text(u'='*width), + cols.options('given', width))) + self._append(node, cols, 'pack') + + def visit_entry(self, node): + self.stack.append(slide.SlidePile([])) + + def depart_entry(self, node): + colindex = self.table_column[-1] + self.table_column[-1] = colindex + 1 + pile = self.stack.pop() + self._append(node, pile, 'given', self.table_columns[-1][colindex]) + + def depart_tgroup(self, node): + self.table_columns.pop() + pile = self.stack.pop() + self._append(node, pile, 'pack') + + def visit_textelement(self, node): + self.stack.append(TextAccumulator()) + + visit_paragraph = visit_textelement + + def depart_paragraph(self, node): + text = self.stack.pop() + self._append(node, urwid.Text(text.getFlowedText()), 'pack') + + visit_literal_block = visit_textelement + + def depart_literal_block(self, node): + text = self.stack.pop() + text = urwid.Text(text.getFormattedText(), wrap='clip') + pad = slide.SlidePadding(text, width='pack') + self._append(node, pad, 'pack') + + visit_line = visit_textelement + + def depart_line(self, node): + text = self.stack.pop() + self._append(node, urwid.Text(text.getFormattedText(), wrap='clip'), + 'pack') + + visit_title = visit_textelement + + def depart_title(self, node): + text = self.stack.pop() + self.slide.title = node.astext() + widget = urwid.Text(self.styled('title', text.getFlowedText()), + align='center') + self.title_pile.contents.append( + (widget, self.title_pile.options('pack'))) + + def visit_Text(self, node): + pass + + def depart_Text(self, node): + if self.stack and isinstance(self.stack[-1], TextAccumulator): + if self.attr: + t = (self.attr[-1], node.astext()) + else: + t = node.astext() + self.stack[-1].append(t) + + def visit_emphasis(self, node): + self.attr.append(self.palette['emphasis']) + + def depart_emphasis(self, node): + self.attr.pop() + + def visit_inline(self, node): + cls = node.get('classes') + if not cls: + raise docutils.nodes.SkipDeparture() + cls = [x for x in cls if x != 'literal'] + for length in range(len(cls), 0, -1): + clsname = '-'.join(cls[:length]) + if clsname in self.palette: + self.attr.append(self.palette[clsname]) + return + raise docutils.nodes.SkipDeparture() + + def depart_inline(self, node): + self.attr.pop() + + def visit_image(self, node): + if not PIL: + return + uri = node['uri'] + fn = os.path.join(self.basedir, uri) + w = image.ANSIImage(fn, self.hinter) + self._append(node, w, 'pack') + + def visit_ansi(self, node): + interval = node.get('interval', 0.5) + oneshot = node.get('oneshot', False) + animation = slide.AnimatedText(interval, oneshot) + for name in node['names']: + p = ansiparser.ANSIParser() + fn = os.path.join(self.basedir, name) + data = unicode(open(fn).read(), 'utf8') + text = p.parse(data) + animation.addFrame(text) + self.slide.animations.append(animation) + self._append(node, animation, 'pack') + + def depart_ansi(self, node): + pass + + def visit_figlet(self, node): + figlet = text.FigletText(node['text']) + self._append(node, figlet, 'pack') + + def depart_figlet(self, node): + pass + + def visit_cowsay(self, node): + cowsay = text.CowsayText(node['text']) + self._append(node, cowsay, 'pack') + + def depart_cowsay(self, node): + pass + + def visit_container(self, node): + self.stack.append(slide.SlidePile([])) + if 'progressive' in node.get('classes'): + self.progressives.append(self.slide.progressives) + self.slide.progressive_attr = self.palette['progressive'] + + def depart_container(self, node): + pile = self.stack.pop() + self._append(node, pile, 'pack') + if 'progressive' in node.get('classes'): + self.progressives.pop() + +class TransitionDirective(docutils.parsers.rst.Directive): + required_arguments = 1 + option_spec = {'duration': float} + has_content = False + + def run(self): + args = {'name': self.arguments[0]} + duration = self.options.get('duration') + if duration: + args['duration'] = duration + node = transition(**args) + return [node] + +class ANSIDirective(docutils.parsers.rst.Directive): + required_arguments = 1 + final_argument_whitespace = True + option_spec = {'interval': float, + 'oneshot': bool} + has_content = False + + def run(self): + args = {'names': self.arguments[0].split()} + args.update(self.options) + node = ansi(**args) + return [node] + +class FigletDirective(docutils.parsers.rst.Directive): + required_arguments = 1 + has_content = False + final_argument_whitespace = True + + def run(self): + args = {'text': self.arguments[0]} + node = figlet(**args) + return [node] + +class CowsayDirective(docutils.parsers.rst.Directive): + required_arguments = 1 + has_content = False + final_argument_whitespace = True + + def run(self): + args = {'text': self.arguments[0]} + node = cowsay(**args) + return [node] + +class HideTitleDirective(docutils.parsers.rst.Directive): + has_content = False + + def run(self): + node = hidetitle() + return [node] + +class transition(docutils.nodes.Special, docutils.nodes.Invisible, + docutils.nodes.Element): + pass + +class ansi(docutils.nodes.General, docutils.nodes.Inline, + docutils.nodes.Element): + pass + +class figlet(docutils.nodes.General, docutils.nodes.Inline, + docutils.nodes.Element): + pass + +class cowsay(docutils.nodes.General, docutils.nodes.Inline, + docutils.nodes.Element): + pass + +class hidetitle(docutils.nodes.Special, docutils.nodes.Invisible, + docutils.nodes.Element): + pass + +class PresentationParser(object): + def __init__(self, palette, hinter=None): + docutils.parsers.rst.directives.register_directive( + 'transition', TransitionDirective) + docutils.parsers.rst.directives.register_directive( + 'ansi', ANSIDirective) + docutils.parsers.rst.directives.register_directive( + 'figlet', FigletDirective) + docutils.parsers.rst.directives.register_directive( + 'cowsay', CowsayDirective) + docutils.parsers.rst.directives.register_directive( + 'hidetitle', HideTitleDirective) + self.warnings = StringIO.StringIO() + self.settings = docutils.frontend.OptionParser( + components=(docutils.parsers.rst.Parser,), + defaults=dict(warning_stream=self.warnings)).get_default_values() + self.parser = docutils.parsers.rst.Parser() + self.palette = palette + self.hinter = hinter + + def _parse(self, input, filename): + document = docutils.utils.new_document(filename, self.settings) + self.parser.parse(input, document) + visitor = UrwidTranslator(document, self.palette, self.hinter, + os.path.dirname(filename)) + document.walkabout(visitor) + return document, visitor + + def parse(self, input, filename='program'): + document, visitor = self._parse(input, filename) + return visitor.program + +def main(): + import argparse + import palette + + argp = argparse.ArgumentParser(description='Test RST parser') + argp.add_argument('file', help='presentation file (RST)') + argp.add_argument('slides', nargs='?', default=[], + help='slides to render') + argp.add_argument('--render', action='store_true', + help='Fully render a slide') + args = argp.parse_args() + + parser = PresentationParser(palette.DARK_PALETTE) + document, visitor = parser._parse(open(args.file).read(), args.file) + + slides = args.slides + if not slides: + slides = range(len(visitor.program)) + slides = [int(x) for x in slides] + + if not args.render: + print document.pformat() + for i in slides: + print '-'*80 + s = visitor.program[i] + for line in s.render((80,25)).text: + print line + else: + screen = urwid.raw_display.Screen() + with screen.start(): + for i in slides: + s = visitor.program[i] + screen.draw_screen((80,25), s.render((80,25))) + raw_input() + +if __name__ == '__main__': + main() |