1 files changed, 292 insertions, 0 deletions

diff --git a/presentty/console.py b/presentty/console.py
new file mode 100644
index 0000000..d29b864
--- /dev/null
+++ b/presentty/console.py
@@ -0,0 +1,292 @@
+# 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 argparse
+import sys
+import datetime
+import time
+
+import urwid
+
+import palette
+import client
+import slide
+import rst
+
+PALETTE = [
+    ('reversed', 'standout', ''),
+    ('status', 'light red', ''),
+]
+
+class Row(urwid.Button):
+    def __init__(self, index, title, console):
+        super(Row, self).__init__('', on_press=console.jump, user_data=index)
+        col = urwid.Columns([
+                ('fixed', 3, urwid.Text('%-2i' % (index+1))),
+                urwid.Text(title),
+                ])
+        self._w = urwid.AttrMap(col, None, focus_map='reversed')
+
+    def selectable(self):
+        return True
+
+class Footer(urwid.WidgetWrap):
+    def __init__(self):
+        super(Footer, self).__init__(urwid.Columns([]))
+        self.position = urwid.Text(u'')
+        self.timer = urwid.Text(u'')
+        self._w.contents.append((self.position, ('pack', None, False)))
+        self._w.contents.append((urwid.Text(u''), ('weight', 1, False)))
+        self._w.contents.append((self.timer, ('pack', None, False)))
+
+class Screen(urwid.WidgetWrap):
+    def __init__(self, console):
+        super(Screen, self).__init__(urwid.Pile([]))
+        self.console = console
+        self.program = []
+        self.current = -1
+        self.progressive_state = 0
+        self.blank_slide = slide.UrwidSlide(
+            u'', None, urwid.Text(u''), None)
+        self.timer = 45*60
+        self.size = (80, 25)
+        self.timer_end = None
+        self.listbox = urwid.ListBox(urwid.SimpleFocusListWalker([]))
+        self.footer = Footer()
+        footer = urwid.AttrMap(self.footer, 'status')
+        self.left = urwid.Pile([])
+        self.left.contents.append((self.listbox, ('weight', 1)))
+        self.left.set_focus(0)
+
+        self.right = urwid.Pile([])
+        self.setPreviews()
+
+        self.main = urwid.Columns([])
+        self.main.contents.append((self.left, ('weight', 1, False)))
+        self.main.contents.append((self.right, ('given', self.size[0]+2, False)))
+        self.main.set_focus(0)
+
+        self._w.contents.append((self.main, ('weight', 1)))
+        self._w.contents.append((footer, ('pack', 1)))
+        self._w.set_focus(0)
+
+    def setPreviews(self):
+        current_slide = next_slide = self.blank_slide
+        if 0 <= self.current < len(self.program):
+            current_slide = self.program[self.current]
+        if 0 <= self.current+1 < len(self.program):
+            next_slide = self.program[self.current+1]
+        current_slide.setProgressive(self.progressive_state)
+        current_box = urwid.LineBox(current_slide, "Current")
+        next_box = urwid.LineBox(next_slide, "Next")
+        if current_slide.handout:
+            notes_box = urwid.LineBox(current_slide.handout, "Notes")
+        else:
+            notes_box = None
+        self.right.contents[:] = []
+        self.left.contents[:] = self.left.contents[:1]
+        cols, rows = self.size
+        self.right.contents.append((current_box, ('given', rows+2)))
+        self.right.contents.append((next_box, ('given', rows+2)))
+        self.right.contents.append((urwid.Filler(urwid.Text(u'')), ('weight', 1)))
+        if notes_box:
+            self.left.contents.append((notes_box, ('pack', None)))
+
+    def setProgram(self, program):
+        self.program = program
+        self.listbox.body[:] = []
+        for i, s in enumerate(program):
+            self.listbox.body.append(Row(i, s.title, self.console))
+
+    def setSize(self, size):
+        self.size = size
+        cols, rows = size
+        self.right.contents[0] = (self.right.contents[0][0], ('given', rows+2))
+        self.right.contents[1] = (self.right.contents[1][0], ('given', rows+2))
+        self.main.contents[1] = (self.main.contents[1][0], ('given', cols+2, False))
+
+    # Implement this method from the urwid screen interface for the ScreenHinter
+    def get_cols_rows(self):
+        return self.size
+
+    def setCurrent(self, state):
+        index, progressive_state = state
+        changed = False
+        if index != self.current:
+            self.current = index
+            self.listbox.set_focus(index)
+            self.listbox._invalidate()
+            self.footer.position.set_text('%i / %i' % (index+1, len(self.program)))
+            changed = True
+        if progressive_state != self.progressive_state:
+            self.progressive_state = progressive_state
+            changed = True
+        if changed:
+            self.setPreviews()
+        self.footer.timer.set_text(self.getTime())
+
+    def getTime(self):
+        now = time.time()
+        if self.timer_end:
+            return str(datetime.timedelta(seconds=(int(self.timer_end-now))))
+        else:
+            return str(datetime.timedelta(seconds=int(self.timer)))
+
+    def setTimer(self, secs):
+        self.timer = secs
+        if self.timer_end:
+            now = time.time()
+            self.timer_end = now + self.timer
+
+    def startStopTimer(self):
+        now = time.time()
+        if self.timer_end:
+            remain = max(self.timer_end - int(now), 0)
+            self.timer = remain
+            self.timer_end = None
+        else:
+            self.timer_end = now + self.timer
+
+    def keypress(self, size, key):
+        if key in (' ', 'x'):
+            self.startStopTimer()
+        elif key == 'page up':
+            self.console.prev()
+        elif key == 'page down':
+            self.console.next()
+        elif key == 'right':
+            self.console.next()
+        elif key == 'left':
+            self.console.prev()
+        elif key == 't':
+            self.console.timerDialog()
+        else:
+            return super(Screen, self).keypress(size, key)
+        return None
+
+class FixedButton(urwid.Button):
+    def sizing(self):
+        return frozenset([urwid.FIXED])
+
+    def pack(self, size, focus=False):
+        return (len(self.get_label())+4, 1)
+
+class TimerDialog(urwid.WidgetWrap):
+    signals = ['set', 'cancel']
+    def __init__(self):
+        set_button = FixedButton('Set')
+        cancel_button = FixedButton('Cancel')
+        urwid.connect_signal(set_button, 'click',
+                             lambda button:self._emit('set'))
+        urwid.connect_signal(cancel_button, 'click',
+                             lambda button:self._emit('cancel'))
+        button_widgets = [('pack', set_button),
+                          ('pack', cancel_button)]
+        button_columns = urwid.Columns(button_widgets, dividechars=2)
+        rows = []
+        self.entry = urwid.Edit('Timer: ', edit_text='45:00')
+        rows.append(self.entry)
+        rows.append(urwid.Divider())
+        rows.append(button_columns)
+        pile = urwid.Pile(rows)
+        fill = urwid.Filler(pile, valign='top')
+        super(TimerDialog, self).__init__(urwid.LineBox(fill, 'Timer'))
+
+    def keypress(self, size, key):
+        r = super(TimerDialog, self).keypress(size, key)
+        if r == 'enter':
+            self._emit('set')
+            return None
+        elif r == 'esc':
+            self._emit('cancel')
+            return None
+        return r
+
+class Console(object):
+    poll_interval = 0.5
+
+    def __init__(self, program):
+        self.screen = Screen(self)
+        self.loop = urwid.MainLoop(self.screen, palette=PALETTE)
+        self.client = client.Client()
+        self.screen.setProgram(program)
+        self.update()
+        self.loop.set_alarm_in(self.poll_interval, self.updateCallback)
+
+    def run(self):
+        self.loop.run()
+
+    def jump(self, widget, index):
+        self.screen.setCurrent(self.client.jump(index))
+
+    def next(self):
+        self.screen.setCurrent(self.client.next())
+
+    def prev(self):
+        self.screen.setCurrent(self.client.prev())
+
+    def updateCallback(self, loop=None, data=None):
+        self.update()
+        self.loop.set_alarm_in(self.poll_interval, self.updateCallback)
+
+    def update(self):
+        self.screen.setSize(self.client.size())
+        self.screen.setCurrent(self.client.current())
+
+    def timerDialog(self):
+        dialog = TimerDialog()
+        overlay = urwid.Overlay(dialog, self.loop.widget,
+                                'center', 30,
+                                'middle', 6)
+        self.loop.widget = overlay
+        urwid.connect_signal(dialog, 'cancel', self.cancelDialog)
+        urwid.connect_signal(dialog, 'set', self.setTimer)
+
+    def cancelDialog(self, widget):
+        self.loop.widget = self.screen
+
+    def setTimer(self, widget):
+        parts = widget.entry.edit_text.split(':')
+        secs = 0
+        if len(parts):
+            secs += int(parts.pop())
+        if len(parts):
+            secs += int(parts.pop())*60
+        if len(parts):
+            secs += int(parts.pop())*60*60
+        self.screen.setTimer(secs)
+        self.loop.widget = self.screen
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Console-based presentation system')
+    parser.add_argument('--light', dest='light',
+                        default=False,
+                        action='store_true',
+                        help='use a black on white palette')
+    parser.add_argument('file',
+                        help='presentation file (RST)')
+    args = parser.parse_args()
+    if args.light:
+        plt = palette.LIGHT_PALETTE
+    else:
+        plt = palette.DARK_PALETTE
+    hinter = slide.ScreenHinter()
+    parser = rst.PresentationParser(plt, hinter)
+    program = parser.parse(open(args.file).read())
+    c = Console(program)
+    hinter.setScreen(c.screen)
+    c.run()