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

#

#	ReportLab Public License Version 1.0

#

#   Except for the change of names the spirit and intention of this

#   license is the same as that of Python

#

#	(C) Copyright ReportLab Inc. 1998-2000.

#

#

# All Rights Reserved

#

# Permission to use, copy, modify, and distribute this software and its

# documentation for any purpose and without fee is hereby granted, provided

# that the above copyright notice appear in all copies and that both that

# copyright notice and this permission notice appear in supporting

# documentation, and that the name of ReportLab not be used

# in advertising or publicity pertaining to distribution of the software

# without specific, written prior permission. 

# 

#

# Disclaimer

#

# ReportLab Inc. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,

# IN NO EVENT SHALL ReportLab BE LIABLE FOR ANY SPECIAL, INDIRECT

# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR

# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

# PERFORMANCE OF THIS SOFTWARE. 

#

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

#	$Log: canvas.py,v $

#	Revision 1.17  2000/03/24 21:02:21  aaron_watters

#	added support for destinations, forms, linkages

#	Revision 1.15  2000/03/10 21:46:04  andy_robinson

#	fixed typo in setDash

#	

#	Revision 1.14  2000/03/08 13:40:03  andy_robinson

#	Canvas has two methods setFillColor(aColor) and setStrokeColor(aColor)

#	which accepts color objects directly.

#	

#	Revision 1.13  2000/03/06 20:06:36  rgbecker

#	Typo self._currentPageHasImages = 1

#	

#	Revision 1.12  2000/03/02 12:58:58  rgbecker

#	Remove over officious import checks Imag/zlib

#	

#	Revision 1.11  2000/03/02 10:28:54  rgbecker

#	[].extend illegal in 1.5.1

#	

#	Revision 1.10  2000/02/24 17:28:13  andy_robinson

#	Added methods setFillGray(g), setStrokeGray(g) where 0 <= g <= 1

#	

#	Revision 1.9  2000/02/24 09:12:55  andy_robinson

#	

#	Removed some constants which are no longer used.

#	

#	Revision 1.8  2000/02/20 14:43:27  rgbecker

#	_currentPageHasImages = 0 in init

#	

#	Revision 1.7  2000/02/20 11:08:56  rgbecker

#	Canvas.setPageSize fix

#	

#	Revision 1.6  2000/02/17 15:26:28  rgbecker

#	Change page compression default

#	

#	Revision 1.5  2000/02/17 02:08:04  rgbecker

#	Docstring & other fixes

#	

#	Revision 1.4  2000/02/16 09:42:50  rgbecker

#	Conversion to reportlab package

#	

#	Revision 1.3  2000/02/15 17:55:59  rgbecker

#	License text fixes

#	

#	Revision 1.2  2000/02/15 15:47:09  rgbecker

#	Added license, __version__ and Logi comment

#	

__doc__=""" 

PDFgen is a library to generate PDF files containing text and graphics.  It is the 

foundation for a complete reporting solution in Python.  It is also the

foundation for piddlePDF, the PDF back end for PIDDLE.

Documentation is a little slim right now; run then look at testpdfgen.py

to get a clue.

Progress Reports:

8.83, 2000-01-13, gmcm:

    Packagizing:

        renamed from pdfgen.py to canvas.py

        broke out PDFTextObject to textobject.py

        broke out PDFPathObject to pathobject.py

        placed all three in a package directory named pdfgen

0.82, 1999-10-27, AR:

        Fixed some bugs on printing to Postscript.  Added 'Text Object'

        analogous to Path Object to control entry and exit from text mode.

        Much simpler clipping API.  All verified to export Postscript and

        redistill.

        One limitation still - clipping to text paths is fine in Acrobat

        but not in Postscript (any level)

0.81,1999-10-13, AR:

        Adding RoundRect; changed all format strings to use %0.2f instead of %s,

        so we don't get exponentials in the output.

0.8,1999-10-07, AR:  all changed!

"""

##  0.81    1999-10-13:

##                

##

##

import os

import sys

import string

import time

import tempfile

import cStringIO

from types import *

from math import sin, cos, tan, pi, ceil

from reportlab.pdfbase import pdfutils

from reportlab.pdfbase import pdfdoc

from reportlab.pdfbase import pdfmetrics

from reportlab.pdfgen  import pdfgeom, pathobject, textobject

from reportlab.lib import colors

# Robert Kern

# Constants for closing paths.

# May be useful if one changes 'arc' and 'rect' to take a

# default argument that tells how to close the path.

# That way we can draw filled shapes.

FILL_EVEN_ODD = 0

FILL_NON_ZERO = 1

    #this is used by path-closing routines.

    #map stroke, fill, fillmode -> operator

    # fillmode: 1 = non-Zero (obviously), 0 = evenOdd

PATH_OPS = {(0, 0, FILL_EVEN_ODD) : 'n',  #no op

            (0, 0, FILL_NON_ZERO) : 'n',  #no op

            (1, 0, FILL_EVEN_ODD) : 'S',  #stroke only

            (1, 0, FILL_NON_ZERO) : 'S',  #stroke only

            (0, 1, FILL_EVEN_ODD) : 'f*',  #Fill only

            (0, 1, FILL_NON_ZERO) : 'f',  #Fill only

            (1, 1, FILL_EVEN_ODD) : 'B*',  #Stroke and Fill

            (1, 1, FILL_NON_ZERO) : 'B',  #Stroke and Fill

            }

class Canvas:

    """This is a low-level interface to the PDF file format.  The plan is to

    expose the whole pdfgen API through this.  Its drawing functions should have a

    one-to-one correspondence with PDF functionality.  Unlike PIDDLE, it thinks

    in terms of RGB values, Postscript font names, paths, and a 'current graphics

    state'.  Just started development at 5/9/99, not in use yet.

    """

    def __init__(self,filename,pagesize=(595.27,841.89), bottomup = 1, pageCompression=0 ):

        """Most of the attributes are private - we will use set/get methods

        as the preferred interface.  Default page size is A4."""

        self._filename = filename

        self._doc = pdfdoc.PDFDocument()

        self._pagesize = pagesize

        #self._currentPageHasImages = 0

        self._pageTransitionString = ''

        self._destinations = {} # dictionary of destinations for cross indexing.

        self._pageCompression = pageCompression  #off by default - turn on when we're happy!

        self._pageNumber = 1   # keep a count

        #self._code = []    #where the current page's marking operators accumulate

        #PostScript has the origin at bottom left. It is easy to achieve a top-

        #down coord system by translating to the top of the page and setting y

        #scale to -1, but then text is inverted.  So self.bottomup is used

        #to also set the text matrix accordingly.  You can now choose your

        #drawing coordinates.

        self.bottomup = bottomup

        self._make_preamble()

        #initial graphics state

        self._x = 0

        self._y = 0

        self._fontname = 'Times-Roman'

        self._fontsize = 12

        self._textMode = 0  #track if between BT/ET

        self._leading = 14.4

        self._currentMatrix = (1., 0., 0., 1., 0., 0.)

        self._fillMode = 0   #even-odd

        #text state        

        self._charSpace = 0

        self._wordSpace = 0

        self._horizScale = 100

        self._textRenderMode = 0

        self._rise = 0

        self._textLineMatrix = (1., 0., 0., 1., 0., 0.)

        self._textMatrix = (1., 0., 0., 1., 0., 0.)

        # line drawing        

        self._lineCap = 0

        self._lineJoin = 0

        self._lineDash = None  #not done

        self._lineWidth = 0

        self._mitreLimit = 0

        self._fillColorRGB = (0,0,0)

        self._strokeColorRGB = (0,0,0)

    def _make_preamble(self):

        if self.bottomup:

            #set initial font

            #self._preamble = 'BT /F9 12 Tf 14.4 TL ET'

            self._preamble = '1 0 0 1 0 0 cm BT /F9 12 Tf 14.4 TL ET'

        else:

            #switch coordinates, flip text and set font

            #self._preamble = '1 0 0 -1 0 %0.2f cm BT /F9 12 Tf 14.4 TL ET' % self._pagesize[1]

            self._preamble = '1 0 0 -1 0 %0.2f cm BT /F9 12 Tf 14.4 TL ET' % self._pagesize[1]

    def _escape(self, s):

        """PDF escapes are like Python ones, but brackets need slashes before them too.

        Use Python's repr function and chop off the quotes first"""

        s = repr(s)[1:-1]

        s = string.replace(s, '(','\(')

        s = string.replace(s, ')','\)')

        return s

    #info functions - non-standard

    def setAuthor(self, author):

        self._doc.setAuthor(author)

    def setTitle(self, title):

        self._doc.setTitle(title)

    def setSubject(self, subject):

        self._doc.setSubject(subject)

    def pageHasData(self):

        "Info function - app can call it after showPage to see if it needs a save"

        return len(self._code) == 0

    def showPage(self):

        """This is where the fun happens"""

        page = pdfdoc.PDFPage()

        page.pagewidth = self._pagesize[0]

        page.pageheight = self._pagesize[1]

        page.hasImages = self._currentPageHasImages

        page.pageTransitionString = self._pageTransitionString

        page.setCompression(self._pageCompression)

        #print stream

        page.setStream([self._preamble] + self._code)

        self._doc.addPage(page)

        #now get ready for the next one

        self._pageNumber = self._pageNumber + 1

        page.Annots = self._annotationrefs

        """for pages and forms, define the XObject dictionary for resources, if needed"""

        forms = self._formsinuse

        if forms:

            xobjectsdict = self._doc.xobjDict(forms)

            thing.XObjects = xobjectsdict

        else:

            thing.XObjects = None

        """get a reference to a (possibly undefined, possibly unbound) bookmark"""

        d = self._destinations

        try:

            return d[name]

        except:

            result = d[name] = pdfdoc.Destination(name) # newly defined, unbound

        return result

    def bookmarkPage(self, name):

        """bind a bookmark (destination) to the current page"""

        # XXXX there are a lot of other ways a bookmark destination can be bound: should be implemented.

        # XXXX the other ways require tracking of the graphics state....

        pageref = self._doc.thisPageRef()

        dest.fit()

        dest.setPageRef(pageref)

        return dest

        """bind a bookmark (destination to the current page at a horizontal position"""

        pageref = self._doc.thisPageRef()

        dest.fith(yhorizontal)

        dest.setPageRef(pageref)

        return dest

    def inPage(self):

        """declare a page, enable page features"""

        self._doc.inPage()

    def inForm(self):

        self._doc.inForm()

    def doForm(self, name):

        """use a form XObj in current operation stream"""

        internalname = self._doc.hasForm(name)

        if not internalname:

            raise ValueError, "form is not defined %s" % name

        self._code.append("/%s Do" % internalname)

        self._formsinuse.append(name)

        self._code = []    # ready for more...

        self._currentPageHasImages = 1 # for safety...

        self._formsinuse = []

        self._annotationrefs = []

    def makeForm(self, name, lowerx=0, lowery=0, upperx=None, uppery=None):

        """Like showpage, but make a form using accumulated operations instead"""

        (w,h) = self._pagesize

        if upperx is None: upperx=w

        if uppery is None: uppery=h

        form = pdfdoc.PDFFormXObject(lowerx=lowerx, lowery=lowery, upperx=upperx, uppery=uppery)

        form.compression = self._pageCompression

        form.setStreamList([self._preamble] + self._code) # ??? minus preamble (seems to be needed!)

        self._doc.addForm(name, form)

    def textAnnotation(self, contents, Rect=None, addtopage=1, name=None, **kw):

        if not Rect:

            (w,h) = self._pagesize# default to whole page (?)

            Rect = (0,0,w,h)

        annotation = apply(pdfdoc.TextAnnotation, (Rect, contents), kw)

    def inkAnnotation(self, contents, InkList=None, Rect=None, addtopage=1, name=None, **kw):

        (w,h) = self._pagesize

        if not Rect:

            Rect = (0,0,w,h)

        if not InkList:

            InkList = ( (100,100,100,h-100,w-100,h-100,w-100,100), )

        annotation = apply(pdfdoc.InkAnnotation, (Rect, contents, InkList), kw)

        self.addAnnotation(annotation, name, addtopage)

        """link annotation positioned wrt the default user space"""

        (w,h) = self._pagesize

        if not Rect:

            Rect = (0,0,w,h)

        kw["Rect"] = Rect

        kw["Contents"] = contents

        kw["Destination"] = destination

        annotation = apply(pdfdoc.LinkAnnotation, (), kw)

        if not name: name="NUMBER"+repr(count)

        self._doc.addAnnotation(name, annotation)

        if addtopage:

        ref = self._doc.refAnnotation(name)

        self._annotationrefs.append(ref)

    def getPageNumber(self):

        return self._pageNumber

    def save(self):

        """Saves the file.  If holding data, do

        a showPage() to save them having to."""

        if len(self._code):  

            self.showPage()

        self._doc.SaveToFile(self._filename)

        print 'saved', self._filename

    def setPageSize(self, size):

        """accepts a 2-tuple in points for paper size for this

        and subsequent pages"""

        self._pagesize = size

        self._make_preamble()

    def addLiteral(self, s, escaped=1):

        if escaped==0:

            s = self._escape(s)

        self._code.append(s)

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

        #

        #      coordinate transformations

        #

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

    def transform(self, a,b,c,d,e,f):

        """How can Python track this?"""

        a0,b0,c0,d0,e0,f0 = self._currentMatrix

        self._currentMatrix = (a0*a+c0*b,    b0*a+d0*b,

                               a0*c+c0*d,    b0*c+d0*d,

                               a0*e+c0*f+e0, b0*e+d0*f+f0)

        self._code.append('%0.2f %0.2f %0.2f %0.2f %0.2f %0.2f cm' % (a,b,c,d,e,f))

    def translate(self, dx, dy):

        self.transform(1,0,0,1,dx,dy)

    def scale(self, x, y):

        self.transform(x,0,0,y,0,0)

    def rotate(self, theta):

        """Canvas.rotate(theta)

        theta is in degrees."""

        c = cos(theta * pi / 180)

        s = sin(theta * pi / 180)

        self.transform(c, s, -s, c, 0, 0)

    def skew(self, alpha, beta):

        tanAlpha = tan(alpha * pi / 180)

        tanBeta  = tan(beta  * pi / 180)

        self.transform(1, tanAlpha, tanBeta, 1, 0, 0)

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

        #

        #      graphics state management

        #

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

    def saveState(self):

        """These need expanding to save/restore Python's state tracking too"""

        self._code.append('q')

    def restoreState(self):

        """These need expanding to save/restore Python's state tracking too"""

        self._code.append('Q')

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

        #

        #   Drawing methods.  These draw things directly without

        #   fiddling around with Path objects.  We can add any geometry

        #   methods we wish as long as their meaning is precise and

        #   they are of general use.

        #

        #   In general there are two patterns.  Closed shapes

        #   have the pattern shape(self, args, stroke=1, fill=0);

        #   by default they draw an outline only. Line segments come

        #   in three flavours: line, bezier, arc (which is a segment

        #   of an elliptical arc, approximated by up to four bezier

        #   curves, one for each quadrant.

        #

        #   In the case of lines, we provide a 'plural' to unroll

        #   the inner loop; it is useful for drawing big grids

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

        #--------first the line drawing methods-----------------------

    def line(self, x1,y1, x2,y2):

        "As it says"       

        self._code.append('n %0.2f %0.2f m %0.2f %0.2f l S' % (x1, y1, x2, y2))

    def lines(self, linelist):

        """As line(), but slightly more efficient for lots of them -

        one stroke operation and one less function call"""

        self._code.append('n')

        for (x1,y1,x2,y2) in linelist:

            self._code.append('%0.2f %0.2f m %0.2f %0.2f l' % (x1, y1, x2, y2))

        self._code.append('S')

    def grid(self, xlist, ylist):

        """Lays out a grid in current line style.  Suuply list of

        x an y positions."""

        assert len(xlist) > 1, "x coordinate list must have 2+ items"

        assert len(ylist) > 1, "y coordinate list must have 2+ items"

        lines = []

        y0, y1 = ylist[0], ylist[-1]

        x0, x1 = xlist[0], xlist[-1]

        for x in xlist:

            lines.append(x,y0,x,y1)

        for y in ylist:

            lines.append(x0,y,x1,y)