#!/usr/bin/env python

"""

This is PythonPoint!

The idea is a simple markup languages for describing presentation

slides, and other documents which run page by page.  I expect most

of it will be reusable in other page layout stuff.

Look at the sample near the top, which shows how the presentation

should be coded up.

The parser, which is in a separate module to allow for multiple

parsers, turns the XML sample into an object tree.  There is a

simple class hierarchy of items, the inner levels of which create

flowable objects to go in the frames.  These know how to draw

themselves.

The currently available 'Presentation Objects' are:

    The main hierarchy...

        PPPresentation

        PPSection

        PPSlide

        PPFrame

        PPAuthor, PPTitle and PPSubject are optional

    Things to flow within frames...

        PPPara - flowing text

        PPPreformatted - text with line breaks and tabs, for code..

        PPImage

        PPTable - bulk formatted tabular data

        PPSpacer

    Things to draw directly on the page...

        PPRect

        PPRoundRect

        PPDrawingElement - user base class for graphics

        PPLine

        PPEllipse

Features added by H. Turgut Uyar <uyar@cs.itu.edu.tr>

- TrueType support (actually, just an import in the style file);

  this also enables the use of Unicode symbols

- para, image, table, line, rectangle, roundrect, ellipse, polygon

  and string elements can now have effect attributes

  (careful: new slide for each effect!)

- added printout mode (no new slides for effects, see item above)

- added a second-level bullet: Bullet2

- small bugfixes in handleHiddenSlides:

    corrected the outlineEntry of included hidden slide

    and made sure to include the last slide even if hidden

Recently added features are:

- file globbing

- package structure

- named colors throughout (using names from reportlab/lib/colors.py)

- handout mode with arbitrary number of columns per page

- stripped off pages hidden in the outline tree (hackish)

- new <notes> tag for speaker notes (paragraphs only)

- new <pycode> tag for syntax-colorized Python code

- reformatted pythonpoint.xml and monterey.xml demos

- written/extended DTD

- arbitrary font support

- print proper speaker notes (TODO)

- fix bug with partially hidden graphics (TODO)

- save in combined presentation/handout mode (TODO)

- add pyRXP support (TODO)

"""

import os, sys, imp, string, pprint, getopt, glob

from reportlab import rl_config

from reportlab.lib import styles

from reportlab.lib import colors

from reportlab.lib.units import cm

from reportlab.lib.utils import getStringIO

from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY

from reportlab.pdfbase import pdfmetrics

from reportlab.pdfgen import canvas

from reportlab.platypus.doctemplate import SimpleDocTemplate

from reportlab.platypus.flowables import Flowable

from reportlab.platypus.xpreformatted import PythonPreformatted

from reportlab.platypus import Preformatted, Paragraph, Frame, \

     Image, Table, TableStyle, Spacer

USAGE_MESSAGE = """\

PythonPoint - a tool for making presentations in PDF.

Usage:

    pythonpoint.py [options] file1.xml [file2.xml [...]]

    where options can be any of these:

        -h / --help     prints this message

        -n / --notes    leave room for comments

        -v / --verbose  verbose mode

        -s / --silent   silent mode (NO output)

        --handout       produce handout document

        --printout      produce printout document

        --cols          specify number of columns

                        on handout pages (default: 2)

To create the PythonPoint user guide, do:

    pythonpoint.py pythonpoint.xml

"""

#####################################################################

# This should probably go into reportlab/lib/fonts.py...

#####################################################################

class FontNameNotFoundError(Exception):

    pass

class FontFilesNotFoundError(Exception):

    pass

##def findFontName(path):

##    "Extract a Type-1 font name from an AFM file."

##

##    f = open(path)

##

##    found = 0

##    while not found:

##        line = f.readline()[:-1]

##        if not found and line[:16] == 'StartCharMetrics':

##            raise FontNameNotFoundError, path

##        if line[:8] == 'FontName':

##            fontName = line[9:]

##            found = 1

##

##    return fontName

##

##

##def locateFilesForFontWithName(name):

##    "Search known paths for AFM/PFB files describing T1 font with given name."

##

##    join = os.path.join

##    splitext = os.path.splitext

##

##    afmFile = None

##    pfbFile = None

##

##    found = 0

##    while not found:

##        for p in rl_config.T1SearchPath:

##            afmFiles = glob.glob(join(p, '*.[aA][fF][mM]'))

##            for f in afmFiles:

##                T1name = findFontName(f)

##                if T1name == name:

##                    afmFile = f

##                    found = 1

##                    break

##            if afmFile:

##                break

##        break

##

##    if afmFile:

##        pfbFile = glob.glob(join(splitext(afmFile)[0] + '.[pP][fF][bB]'))[0]

##

##    return afmFile, pfbFile

##

##

##def registerFont(name):

##    "Register Type-1 font for future use."

##

##    rl_config.warnOnMissingFontGlyphs = 0

##    rl_config.T1SearchPath.append(r'C:\Programme\Python21\reportlab\test')

##

##    afmFile, pfbFile = locateFilesForFontWithName(name)

##    if not afmFile and not pfbFile:

##        raise FontFilesNotFoundError

##

##    T1face = pdfmetrics.EmbeddedType1Face(afmFile, pfbFile)

##    T1faceName = name

##    pdfmetrics.registerTypeFace(T1face)

##    T1font = pdfmetrics.Font(name, T1faceName, 'WinAnsiEncoding')

##    pdfmetrics.registerFont(T1font)

def registerFont0(sourceFile, name, path):

    "Register Type-1 font for future use, simple version."

    rl_config.warnOnMissingFontGlyphs = 0

    p = os.path.join(os.path.dirname(sourceFile), path)

    afmFiles = glob.glob(p + '.[aA][fF][mM]')

    pfbFiles = glob.glob(p + '.[pP][fF][bB]')

    assert len(afmFiles) == len(pfbFiles) == 1, FontFilesNotFoundError

    T1face = pdfmetrics.EmbeddedType1Face(afmFiles[0], pfbFiles[0])

    T1faceName = name

    pdfmetrics.registerTypeFace(T1face)

    T1font = pdfmetrics.Font(name, T1faceName, 'WinAnsiEncoding')

    pdfmetrics.registerFont(T1font)

#####################################################################

def checkColor(col):

    "Converts a color name to an RGB tuple, if possible."

    if type(col) == type('') and col in dir(colors):

        col = getattr(colors, col)

        col = (col.red, col.green, col.blue)

    return col

def handleHiddenSlides(slides):

    """Filters slides from a list of slides.

    In a sequence of hidden slides all but the last one are

    removed. Also, the slide before the sequence of hidden

    ones is removed.

    This assumes to leave only those slides in the handout

    that also appear in the outline, hoping to reduce se-

    quences where each new slide only adds one new line

    to a list of items...

    """

    itd = indicesToDelete = map(lambda s:s.outlineEntry == None, slides)

    for i in range(len(itd)-1):

        if itd[i] == 1:

            if itd[i+1] == 0:

                itd[i] = 0

            if i > 0 and itd[i-1] == 0:

                itd[i-1] = 1

    itd[len(itd)-1] = 0

    for i in range(len(itd)):

        if slides[i].outlineEntry:

            curOutlineEntry = slides[i].outlineEntry

        if itd[i] == 1:

            slides[i].delete = 1

        else:

            slides[i].outlineEntry = curOutlineEntry

            slides[i].delete = 0

    slides = filter(lambda s:s.delete == 0, slides)

    return slides

def makeSlideTable(slides, pageSize, docWidth, numCols):

    """Returns a table containing a collection of SlideWrapper flowables.

    """

    slides = handleHiddenSlides(slides)

    # Set table style.

    tabStyle = TableStyle(

        [('GRID', (0,0), (-1,-1), 0.25, colors.black),

        ('ALIGN', (0,0), (-1,-1), 'CENTRE')

         ])

    # Build table content.

    width = docWidth/numCols

    height = width * pageSize[1]/pageSize[0]

    matrix = []

    row = []

    for slide in slides:

        sw = SlideWrapper(width, height, slide, pageSize)

        if (len(row)) < numCols:

            row.append(sw)

        else:

            matrix.append(row)

            row = []

            row.append(sw)

    if len(row) > 0:

        for i in range(numCols-len(row)):

            row.append('')

        matrix.append(row)

    # Make Table flowable.

    t = Table(matrix,

              [width + 5]*len(matrix[0]),

              [height + 5]*len(matrix))

    t.setStyle(tabStyle)

    return t

class SlideWrapper(Flowable):

    """A Flowable wrapping a PPSlide object.

    """

    def __init__(self, width, height, slide, pageSize):

        Flowable.__init__(self)

        self.width = width

        self.height = height

        self.slide = slide

        self.pageSize = pageSize

    def __repr__(self):

        return "SlideWrapper(w=%s, h=%s)" % (self.width, self.height)

    def draw(self):

        "Draw the slide in our relative coordinate system."

        slide = self.slide

        pageSize = self.pageSize

        canv = self.canv

        canv.saveState()

        canv.scale(self.width/pageSize[0], self.height/pageSize[1])

        slide.effectName = None

        slide.drawOn(self.canv)

        canv.restoreState()

class PPPresentation:

    def __init__(self):

        self.sourceFilename = None

        self.filename = None

        self.outDir = None

        self.description = None

        self.title = None

        self.author = None

        self.subject = None

        self.notes = 0          # different printing mode

        self.handout = 0        # prints many slides per page

        self.printout = 0       # remove hidden slides

        self.cols = 0           # columns per handout page

        self.slides = []

        self.effectName = None

        self.showOutline = 1   #should it be displayed when opening?

        self.compression = rl_config.pageCompression

        self.pageDuration = None

        #assume landscape

        self.pageWidth = rl_config.defaultPageSize[1]

        self.pageHeight = rl_config.defaultPageSize[0]

        self.verbose = rl_config.verbose

    def saveAsPresentation(self):

        """Write the PDF document, one slide per page."""

        if self.verbose:

            print 'saving presentation...'

        pageSize = (self.pageWidth, self.pageHeight)

        if self.sourceFilename:

            filename = os.path.splitext(self.sourceFilename)[0] + '.pdf'

        if self.outDir: filename = os.path.join(self.outDir,os.path.basename(filename))

        if self.verbose:

            print filename

        #canv = canvas.Canvas(filename, pagesize = pageSize)

        outfile = getStringIO()

        if self.notes:

            #translate the page from landscape to portrait

            pageSize= pageSize[1], pageSize[0]

        canv = canvas.Canvas(outfile, pagesize = pageSize)

        canv.setPageCompression(self.compression)

        canv.setPageDuration(self.pageDuration)

        if self.title:

            canv.setTitle(self.title)

        if self.author:

            canv.setAuthor(self.author)

        if self.subject:

            canv.setSubject(self.subject)

        slideNo = 0

        for slide in self.slides:

            #need diagnostic output if something wrong with XML

            slideNo = slideNo + 1

            if self.verbose:

                print 'doing slide %d, id = %s' % (slideNo, slide.id)

            if self.notes:

                #frame and shift the slide

                #canv.scale(0.67, 0.67)

                scale_amt = (min(pageSize)/float(max(pageSize)))*.95

                #canv.translate(self.pageWidth / 6.0, self.pageHeight / 3.0)

                #canv.translate(self.pageWidth / 2.0, .025*self.pageHeight)

                canv.translate(.025*self.pageHeight, (self.pageWidth/2.0) + 5)

                #canv.rotate(90)

                canv.scale(scale_amt, scale_amt)

                canv.rect(0,0,self.pageWidth, self.pageHeight)

            slide.drawOn(canv)

            canv.showPage()

        #ensure outline visible by default

        if self.showOutline:

            canv.showOutline()

        canv.save()

        return self.savetofile(outfile, filename)

    def saveAsHandout(self):

        """Write the PDF document, multiple slides per page."""

        styleSheet = getSampleStyleSheet()

        h1 = styleSheet['Heading1']

        bt = styleSheet['BodyText']

        if self.sourceFilename :

            filename = os.path.splitext(self.sourceFilename)[0] + '.pdf'

        outfile = getStringIO()

        doc = SimpleDocTemplate(outfile, pagesize=rl_config.defaultPageSize, showBoundary=0)

        doc.leftMargin = 1*cm

        doc.rightMargin = 1*cm

        doc.topMargin = 2*cm

        doc.bottomMargin = 2*cm

        multiPageWidth = rl_config.defaultPageSize[0] - doc.leftMargin - doc.rightMargin - 50

        story = []

        orgFullPageSize = (self.pageWidth, self.pageHeight)

        t = makeSlideTable(self.slides, orgFullPageSize, multiPageWidth, self.cols)

        story.append(t)

##        #ensure outline visible by default

##        if self.showOutline:

##            doc.canv.showOutline()

        doc.build(story)

        return self.savetofile(outfile, filename)

    def savetofile(self, pseudofile, filename):

        """Save the pseudo file to disk and return its content as a

        string of text."""

        pseudofile.flush()

        content = pseudofile.getvalue()

        pseudofile.close()

        if filename :

            outf = open(filename, "wb")

            outf.write(content)

            outf.close()

        return content

    def save(self):

        "Save the PDF document."

        if self.handout:

            return self.saveAsHandout()

        else:

            return self.saveAsPresentation()

#class PPSection:

#   """A section can hold graphics which will be drawn on all

#   pages within it, before frames and other content are done.

#  In other words, a background template."""

#    def __init__(self, name):

#       self.name = name

#        self.graphics = []

#

#    def drawOn(self, canv):

#        for graphic in self.graphics:

###            graphic.drawOn(canv)

#

#            name = str(hash(graphic))

#            internalname = canv._doc.hasForm(name)

#

#            canv.saveState()

#            if not internalname:

#                canv.beginForm(name)

#                graphic.drawOn(canv)

#                canv.endForm()

#                canv.doForm(name)

#            else:

#                canv.doForm(name)

#            canv.restoreState()

definedForms = {}

class PPSection:

    """A section can hold graphics which will be drawn on all

    pages within it, before frames and other content are done.

    In other words, a background template."""

    def __init__(self, name):

        self.name = name

        self.graphics = []

    def drawOn(self, canv):

        for graphic in self.graphics:

            graphic.drawOn(canv)

            continue

            name = str(hash(graphic))

            #internalname = canv._doc.hasForm(name)

            if definedForms.has_key(name):

                internalname = 1

            else:

                internalname = None

                definedForms[name] = 1

            if not internalname:

                canv.beginForm(name)

                canv.saveState()

                graphic.drawOn(canv)

                canv.restoreState()

                canv.endForm()

                canv.doForm(name)

            else:

                canv.doForm(name)

class PPNotes:

    def __init__(self):

        self.content = []

    def drawOn(self, canv):

        print self.content

class PPSlide:

    def __init__(self):

        self.id = None

        self.title = None

        self.outlineEntry = None

        self.outlineLevel = 0   # can be higher for sub-headings

        self.effectName = None

        self.effectDirection = 0

        self.effectDimension = 'H'

        self.effectMotion = 'I'

        self.effectDuration = 1