#format PYTHON
# -*- coding: iso-8859-1 -*-
"""
    MoinMoin - slideshow action

    Usage - Used together with the [[Slide]] macro allows a slideshow to be
            defined on a single wiki page.

            Create a page with the format:

                general introduction or comments
                [[Slide]]
                Slide 1 contents
                [[Slide]]
                Slide 2 contents
                ...
                [[Slide]]
                Final slide contents

            The [[Slide]] macro creates links to the slideshow action.  The
            slideshow action takes a parameter 'slidenumber', which is the
            (1-based) number of the slide to display.  The display uses the
            large screen 'projection' media.

            This action adds two sets of navigation aids for the slides:
            1) some javascript, so that mouse clicks or space bar move to the next page
            2) a navigation footer, similar to the [[Navigation]] macro

    @copyright: 2005 Jim Clark
    @license: GNU GPL, see COPYING for details.
"""

import re
from MoinMoin import config, wikiutil
from MoinMoin.Page import Page
from MoinMoin.parser.wiki import Parser
from MoinMoin.formatter.text_html import Formatter


class slideshow:
    slide_pattern = re.compile(r'\[\[Slide\]\]')
    script_template = """
<script type="text/javascript"><!--
function firstSlide() {window.location="%s"}
function prevSlide() {window.location="%s"}
function nextSlide() {window.location="%s"}
function lastSlide() {window.location="%s"}
function handleKey(e) {
    var key;
    if (e == null) {key = event.keyCode} //IE
    else {if (e.altKey || e.ctrlKey) {return true} key = e.which} // Mozilla
    switch(key) {
        case 49: firstSlide(); break //'1'
        case 32: nextSlide(); break  //space
        case 60: prevSlide(); break  //'<'
        case 62: nextSlide(); break  //'>'
        default:
    }
}
document.onkeypress = handleKey
document.onclick = nextSlide
document.ondblclick = prevSlide
//-->
</script>"""

    def __init__(self, pagename, request):
        self.pagename = pagename
        try:
            self.slidenumber = int(request.form.get('slidenumber', [1])[0])
        except ValueError:
            self.slidenumber = 1
        request.formatter = Formatter(request)
        request.page = Page(request, pagename)
        request.formatter.page = request.page
        self.request = request
        self.page = self.request.page
        self.formatter = self.request.formatter
        self._parseslides()
        
    def _parseslides(self):
        """ Parse slide content from the base page.  The simple parser currently
        uses the [[Slide]] macro as the delimeter - perhaps it would be better
        to do this automatically based on eg H1 markers?
        """
        self.slideinfo = []
        startpos = 0
        # setup slideinfo as a list of tuples representing the start and end
        # characters of each slides content
        for match in self.slide_pattern.finditer(self.request.page.get_raw_body()):
            self.slideinfo.append((startpos, match.start()))
            startpos = match.end()
        if startpos:
            self.slideinfo.append((startpos, len(self.request.page.get_raw_body())))

    def slideurl(self, slidenumber):
        """ Return a url for a link to another slide based on this page
        """
        return "%s/%s?action=slideshow&slidenumber=%d" % \
               (self.request.getScriptname(), self.pagename, slidenumber)

    def navigationscript(self):
        """ Return a section of javascript for capturing mouse button and
        keyboard events and using for slide navigation.
        """
        urls = (self.slideurl(1),
                self.slideurl(self.slidenumber - 1),
                self.slideurl(self.slidenumber + 1),
                self.slideurl(len(self.slideinfo) - 1))
        return (self.script_template % urls)

    def navigationtable(self):
        """ Return an HTML table for navigating between slides
        """
        items = []
        items.append(self.page.link_to(self.request, text='End'))
        items.append(self.page.link_to(self.request, text='Edit', querystr='action=edit'))
        items.append(self.page.link_to(self.request, text='|<', querystr='action=slideshow&slidenumber=%d' % 1))
        items.append(self.page.link_to(self.request, text='<<', querystr='action=slideshow&slidenumber=%d' % (self.slidenumber - 1)))
        items.append('Slide %d of %d' % (self.slidenumber, len(self.slideinfo) - 1))
        items.append(self.page.link_to(self.request, text='>>', querystr='action=slideshow&slidenumber=%d' % (self.slidenumber + 1)))
        items.append(self.page.link_to(self.request, text='>|', querystr='action=slideshow&slidenumber=%d' % (len(self.slideinfo) - 1)))

        return self.formatter.table(1, {'tableclass': 'navigation'}) + \
               self.formatter.table_row(1) + \
               self.formatter.table_cell(1) + \
               ' &nbsp; '.join(items) + \
               self.formatter.table_cell(0) + \
               self.formatter.table_row(0) + \
               self.formatter.table(0)


    def render(self):
        """ Render a slide from a page """
        request = self.request
        if self.slidenumber < 1 or self.slidenumber > len(self.slideinfo) - 1:
            request.http_headers()
            request.page.send_page(request, msg='End of slides') 
            return
        
        # Extract the requsted slide content from the page body and parse it
        # as a wiki page in its own right
        (startpos, endpos) = self.slideinfo[self.slidenumber]
        slide = request.page.get_raw_body()[startpos:endpos]
        parser = Parser(slide, request)

        request.http_headers()
        request.setContentLanguage(request.lang)
        
        # Send the header in 'projection' mode - for large print and no headings
        wikiutil.send_title(request, self.page.split_title(request, force=1),
                            print_mode=1, media='projection')

        # Write the extracted slide, as well as the navigation aids
        request.write(self.navigationscript())
        request.write(request.formatter.startContent("content"))
        parser.format(request.formatter)
        request.write(self.navigationtable())
        request.write(request.formatter.endContent())
        wikiutil.send_footer(request, self.pagename, print_mode=1)

def execute(pagename, request):
    slideshow(pagename, request).render()