#Copyright ReportLab Europe Ltd. 2000-2012

#see license.txt for license details

__version__=''' $Id$ '''

__doc__="""

The Canvas object is the primary interface for creating PDF files. See

doc/reportlab-userguide.pdf for copious examples.

"""

__all__ = ['Canvas']

ENABLE_TRACKING = 1 # turn this off to do profile testing w/o tracking

import os

import sys

import re

import tempfile

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

from reportlab import rl_config

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.colors import black, _chooseEnforceColorSpace, Color, CMYKColor, toColor

from reportlab.lib.boxstuff import aspectRatioFix

digitPat = re.compile('\d')  #used in decimal alignment

zlib = import_zlib()

# 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

            }

_escapePDF = pdfutils._escape

_instanceEscapePDF = pdfutils._instanceEscapePDF

def _annFormat(D,color,thickness,dashArray,hradius=0,vradius=0):

    from reportlab.pdfbase.pdfdoc import PDFArray, PDFDictionary

    if color and 'C' not in D:

        D["C"] = PDFArray([color.red, color.green, color.blue])

    if 'Border' not in D:

        border = [hradius,vradius,thickness or 0]

        if dashArray:

            border.append(PDFArray(dashArray))

        D["Border"] = PDFArray(border)

#   BS = PDFDictionary()

#   bss = 'S'

#   if dashArray:

#       BS['D'] = PDFArray(dashArray)

#       bss = 'D'

#   BS['W'] = thickness or 0

#   BS['S'] = bss

#   D['BS'] = BS

# helpers to guess color space for gradients

def _normalizeColor(aColor):

    if isinstance(aColor, CMYKColor):

        d = aColor.density

        return "DeviceCMYK", tuple(c*d for c in aColor.cmyk())

    elif isinstance(aColor, Color):

        return "DeviceRGB", aColor.rgb()

    elif isinstance(aColor, (tuple, list)):

        l = len(aColor)

        if l == 3:

            return "DeviceRGB", aColor

        elif l == 4:

            return "DeviceCMYK", aColor

    elif isinstance(aColor, str):

        return _normalizeColor(toColor(aColor))

    raise ValueError("Unknown color %r" % aColor)

def _normalizeColors(colors):

    space = None

    outcolors = []

    for aColor in colors:

        nspace, outcolor = _normalizeColor(aColor)

        if space is not None and space != nspace:

            raise ValueError("Mismatch in color spaces: %s and %s" % (space, nspace))

        space = nspace

        outcolors.append(outcolor)

    return space, outcolors

def _buildColorFunction(colors, positions):

    from reportlab.pdfbase.pdfdoc import PDFExponentialFunction, PDFStitchingFunction

    if positions is not None and len(positions) != len(colors):

        raise ValueError("need to have the same number of colors and positions")

    # simplified functions for edge cases

    if len(colors) == 1:

        # for completeness

        return PDFExponentialFunction(N=1, C0=colors[0], C1=colors[0])

    if len(colors) == 2:

        if positions is None or (positions[0] == 0 and positions[1] == 1):

            return PDFExponentialFunction(N=1, C0=colors[0], C1=colors[1])

    # equally distribute if positions not specified

    if positions is None:

        nc = len(colors)

        positions = [(1.0*x)/(nc-1) for x in range(nc)]

    else:

        # sort positions and colors in increasing order

        poscolors = list(zip(positions, colors))

        poscolors.sort(key=lambda x: x[0])

        # add endpoint positions if not already present

        if poscolors[0][0] != 0:

            poscolors.insert(0, (0.0, poscolors[0][1]))

        if poscolors[-1][0] != 1:

            poscolors.append((1.0, poscolors[-1][1]))

        positions, colors = list(zip(*poscolors)) # unzip

    # build stitching function

    functions = []

    bounds = [pos for pos in positions[1:-1]]

    encode = []

    lastcolor = colors[0]

    for color in colors[1:]:

        functions.append(PDFExponentialFunction(N=1, C0=lastcolor, C1=color))

        lastcolor = color

        encode.append(0.0)

        encode.append(1.0)

    return PDFStitchingFunction(functions, bounds, encode, Domain="[0.0 1.0]")

class   ExtGState:

    defaults = dict(

                CA=1,

                ca=1,

                OP=False,

                op=False,

                OPM=0,

                )

    def __init__(self):

        self._d = {}

        self._c = {}

    def set(self,canv,a,v):

        d = self.defaults[a]

        isbool = isinstance(d,bool)

        if isbool: v=bool(v)

        if v!=self._d.get(a,d) or (a=='op' and self.getValue('OP')!=d):

            self._d[a] = v

            if isbool: v=str(v).lower()

            t = a,v

            if t in self._c:

                name = self._c[t]

            else:

                name = 'gRLs'+str(len(self._c))

                self._c[t] = name

            canv._code.append('/%s gs' % name)

    def getValue(self,a):

        return self._d.get(a,self.defaults[a])

    def getState(self):

        S = {}

        for t,name in self._c.items():

            S[name] = pdfdoc.PDFDictionary(dict((t,)))

        return S and pdfdoc.PDFDictionary(S) or None

    def pushCopy(self):

        '''the states must be shared across push/pop, but the values not'''

        x = self.__class__()

        x._d = self._d.copy()

        x._c = self._c

        return x

class Canvas(textobject._PDFColorSetter):

    """This class is the programmer's interface to the PDF file format.  Methods

    are (or will be) provided here to do just about everything PDF can do.

    The underlying model to the canvas concept is that of a graphics state machine

    that at any given point in time has a current font, fill color (for figure

    interiors), stroke color (for figure borders), line width and geometric transform, among

    many other characteristics.

    Canvas methods generally either draw something (like canvas.line) using the

    current state of the canvas or change some component of the canvas

    state (like canvas.setFont).  The current state can be saved and restored

    using the saveState/restoreState methods.

    Objects are "painted" in the order they are drawn so if, for example

    two rectangles overlap the last draw will appear "on top".  PDF form

    objects (supported here) are used to draw complex drawings only once,

    for possible repeated use.

    There are other features of canvas which are not visible when printed,

    such as outlines and bookmarks which are used for navigating a document

    in a viewer.

    Here is a very silly example usage which generates a Hello World pdf document.

    Example:: 

       from reportlab.pdfgen import canvas

       c = canvas.Canvas("hello.pdf")

       from reportlab.lib.units import inch

       # move the origin up and to the left

       c.translate(inch,inch)

       # define a large font

       c.setFont("Helvetica", 80)

       # choose some colors

       c.setStrokeColorRGB(0.2,0.5,0.3)

       c.setFillColorRGB(1,0,1)

       # draw a rectangle

       c.rect(inch,inch,6*inch,9*inch, fill=1)

       # make text go straight up

       c.rotate(90)

       # change color

       c.setFillColorRGB(0,0,0.77)

       # say hello (note after rotate the y coord needs to be negative!)

       c.drawString(3*inch, -3*inch, "Hello World")

       c.showPage()

       c.save()

    """

    def __init__(self,filename,

                 pagesize=None,

                 bottomup = 1,

                 pageCompression=None,

                 invariant = None,

                 verbosity=0,

                 encrypt=None,

                 cropMarks=None,

                 pdfVersion=None,

                 enforceColorSpace=None,

                 ):

        """Create a canvas of a given size. etc.

        You may pass a file-like object to filename as an alternative to

        a string.

        For more information about the encrypt parameter refer to the setEncrypt method.

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

        as the preferred interface.  Default page size is A4.

        cropMarks may be True/False or an object with parameters borderWidth, markColor, markWidth

        and markLength

        if enforceColorSpace is in ('cmyk', 'rgb', 'sep','sep_black','sep_cmyk') then one of

        the standard _PDFColorSetter callables will be used to enforce appropriate color settings.

        If it is a callable then that will be used.

        """

        if pagesize is None: pagesize = rl_config.defaultPageSize

        if invariant is None: invariant = rl_config.invariant

        self._filename = filename

        self._doc = pdfdoc.PDFDocument(compression=pageCompression,

                                       invariant=invariant, filename=filename,

                                       pdfVersion=pdfVersion or pdfdoc.PDF_VERSION_DEFAULT,

                                       )

        self._enforceColorSpace = _chooseEnforceColorSpace(enforceColorSpace)

        #this only controls whether it prints 'saved ...' - 0 disables

        self._verbosity = verbosity

        #this is called each time a page is output if non-null

        self._onPage = None

        self._cropMarks = cropMarks

        self._pagesize = pagesize

        self._pageRotation = 0

        #self._currentPageHasImages = 0

        self._pageTransition = None

        self._pageDuration = None

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

        self.setPageCompression(pageCompression)

        self._pageNumber = 1   # keep a count

        # when we create a form we need to save operations not in the form

        self._codeStack = []

        self._restartAccumulators()  # restart all accumulation state (generalized, arw)

        self._annotationCount = 0

        self._outlines = [] # list for a name tree

        self._psCommandsBeforePage = [] #for postscript tray/font commands

        self._psCommandsAfterPage = [] #for postscript tray/font commands

        #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.imageCaching = rl_config.defaultImageCaching

        self.init_graphics_state()

        self._make_preamble()

        self.state_stack = []

        self.setEncrypt(encrypt)

    def setEncrypt(self, encrypt):

        '''

        Set the encryption used for the pdf generated by this canvas.

        If encrypt is a string object, it is used as the user password for the pdf.

        If encrypt is an instance of reportlab.lib.pdfencrypt.StandardEncryption, this object is

        used to encrypt the pdf. This allows more finegrained control over the encryption settings.

        '''

        if encrypt:

            from reportlab.lib import pdfencrypt

                    encrypt = encrypt.encode('utf-8')

                encrypt = pdfencrypt.StandardEncryption(encrypt)    #now it's the encrypt object

                encrypt.setAllPermissions(1)

            elif not isinstance(encrypt, pdfencrypt.StandardEncryption):

                raise TypeError('Expected string or instance of reportlab.lib.pdfencrypt.StandardEncryption as encrypt parameter but got %r' % encrypt)

            self._doc.encrypt = encrypt

        else:

            try:

                del self._doc.encrypt

            except AttributeError:

                pass

    def init_graphics_state(self):

        #initial graphics state, never modify any of these in place

        self._x = 0

        self._y = 0

        self._fontname = rl_config.canvas_basefontname

        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._fillColorObj = self._strokeColorObj = rl_config.canvas_baseColor or (0,0,0)

        self._extgstate = ExtGState()

    def push_state_stack(self):

        state = {}

        d = self.__dict__

        for name in self.STATE_ATTRIBUTES:

            state[name] = d[name] #getattr(self, name)

        self.state_stack.append(state)

        self._extgstate = self._extgstate.pushCopy()

    def pop_state_stack(self):

        state = self.state_stack[-1]

        del self.state_stack[-1]

        d = self.__dict__

        d.update(state)

     _fillMode _charSpace _wordSpace _horizScale _textRenderMode _rise _textLineMatrix

     _textMatrix _lineCap _lineJoin _lineDash _lineWidth _mitreLimit _fillColorObj

    STATE_RANGE = list(range(len(STATE_ATTRIBUTES)))

        #self._addStandardFonts()

    def _make_preamble(self):

        P = [].append

        if self.bottomup:

            P('1 0 0 1 0 0 cm')

        else:

            P('1 0 0 -1 0 %s cm' % fp_str(self._pagesize[1]))

        C = self._code

        n = len(C)

        if self._fillColorObj != (0,0,0):

            self.setFillColor(self._fillColorObj)

        if self._strokeColorObj != (0,0,0):

            self.setStrokeColor(self._strokeColorObj)

        P(' '.join(C[n:]))

        del C[n:]

        font = pdfmetrics.getFont(self._fontname)

        if not font._dynamicFont:

            #set an initial font

            if font.face.builtIn or not getattr(self,'_drawTextAsPath',False):

                P('BT %s 12 Tf 14.4 TL ET' % self._doc.getInternalFontName(self._fontname))

        self._preamble = ' '.join(P.__self__)

    if not _instanceEscapePDF:

        def _escape(self, s):

            return _escapePDF(s)

    #info functions - non-standard

    def setAuthor(self, author):

        """identify the author for invisible embedding inside the PDF document.

           the author annotation will appear in the the text of the file but will

           not automatically be seen when the document is viewed, but is visible

           in document properties etc etc."""

        self._doc.setAuthor(author)

    def setDateFormatter(self, dateFormatter):

        """accepts a func(yyyy,mm,dd,hh,m,s) used to create embedded formatted date"""

        self._doc.setDateFormatter(dateFormatter)

    def addOutlineEntry(self, title, key, level=0, closed=None):

        """Adds a new entry to the outline at given level.  If LEVEL not specified,

        entry goes at the top level.  If level specified, it must be

        no more than 1 greater than the outline level in the last call.

        The key must be the (unique) name of a bookmark.

        the title is the (non-unique) name to be displayed for the entry.

        If closed is set then the entry should show no subsections by default

        when displayed.

        Example::

           c.addOutlineEntry("first section", "section1")

           c.addOutlineEntry("introduction", "s1s1", 1, closed=1)

           c.addOutlineEntry("body", "s1s2", 1)

           c.addOutlineEntry("detail1", "s1s2s1", 2)

           c.addOutlineEntry("detail2", "s1s2s2", 2)

           c.addOutlineEntry("conclusion", "s1s3", 1)

           c.addOutlineEntry("further reading", "s1s3s1", 2)

           c.addOutlineEntry("second section", "section1")

           c.addOutlineEntry("introduction", "s2s1", 1)

           c.addOutlineEntry("body", "s2s2", 1, closed=1)

           c.addOutlineEntry("detail1", "s2s2s1", 2)

           c.addOutlineEntry("detail2", "s2s2s2", 2)

           c.addOutlineEntry("conclusion", "s2s3", 1)

           c.addOutlineEntry("further reading", "s2s3s1", 2)

        generated outline looks like::

            - first section

            |- introduction

            |- body

            |  |- detail1

            |  |- detail2

            |- conclusion

            |  |- further reading

            - second section

            |- introduction

            |+ body

            |- conclusion

            |  |- further reading

        Note that the second "body" is closed.

        Note that you can jump from level 5 to level 3 but not

        from 3 to 5: instead you need to provide all intervening

        levels going down (4 in this case).  Note that titles can

        collide but keys cannot.

        """

        #to be completed

        #self._outlines.append(title)

        self._doc.outline.addOutlineEntry(key, level, title, closed=closed)

    def setOutlineNames0(self, *nametree):   # keep this for now (?)

        """nametree should can be a recursive tree like so::

               c.setOutlineNames(

                 "chapter1dest",

                 ("chapter2dest",

                  ["chapter2section1dest",

                   "chapter2section2dest",

                   "chapter2conclusiondest"]

                 ), # end of chapter2 description

                 "chapter3dest",

                 ("chapter4dest", ["c4s1", "c4s2"])

                 )