#Copyright ReportLab Europe Ltd. 2000-2012

#see license.txt for license details

#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/graphics/shapes.py

__version__=''' $Id$ '''

__doc__='''Core of the graphics library - defines Drawing and Shapes'''

import string, os, sys

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

from types import FloatType, IntType, ListType, TupleType, StringType, InstanceType

from pprint import pprint

from reportlab.platypus import Flowable

from reportlab.rl_config import shapeChecking, verbose, defaultGraphicsFontName as _baseGFontName, _unset_

from reportlab.lib import logger

from reportlab.lib import colors

from reportlab.lib.validators import *

isOpacity = NoneOr(isNumberInRange(0,1))

from reportlab.lib.attrmap import *

from reportlab.lib.utils import fp_str

from reportlab.pdfbase.pdfmetrics import stringWidth

from reportlab.lib.fonts import tt2ps

_baseGFontNameB = tt2ps(_baseGFontName,1,0)

_baseGFontNameI = tt2ps(_baseGFontName,0,1)

_baseGFontNameBI = tt2ps(_baseGFontName,1,1)

class NotImplementedError(Exception):

    pass

# two constants for filling rules

NON_ZERO_WINDING = 'Non-Zero Winding'

EVEN_ODD = 'Even-Odd'

## these can be overridden at module level before you start

#creating shapes.  So, if using a special color model,

#this provides support for the rendering mechanism.

#you can change defaults globally before you start

#making shapes; one use is to substitute another

#color model cleanly throughout the drawing.

STATE_DEFAULTS = {   # sensible defaults for all

    'transform': (1,0,0,1,0,0),

    # styles follow SVG naming

    'strokeColor': colors.black,

    'strokeWidth': 1,

    'strokeLineCap': 0,

    'strokeLineJoin': 0,

    'strokeMiterLimit' : 10,    # don't know yet so let bomb here

    'strokeDashArray': None,

    'strokeOpacity': None, #100%

    'fillOpacity': None,

    'fillOverprint': False,

    'strokeOverprint': False,

    'overprintMask': 0,

    'fillColor': colors.black,   #...or text will be invisible

    #'fillRule': NON_ZERO_WINDING, - these can be done later

    'fontSize': 10,

    'fontName': _baseGFontName,

    'textAnchor':  'start' # can be start, middle, end, inherited

    }

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

# math utilities.  These could probably be moved into lib

# somewhere.

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

# constructors for matrices:

def nullTransform():

    return (1, 0, 0, 1, 0, 0)

def translate(dx, dy):

    return (1, 0, 0, 1, dx, dy)

def scale(sx, sy):

    return (sx, 0, 0, sy, 0, 0)

def rotate(angle):

    a = angle * pi/180

    return (cos(a), sin(a), -sin(a), cos(a), 0, 0)

def skewX(angle):

    a = angle * pi/180

    return (1, 0, tan(a), 1, 0, 0)

def skewY(angle):

    a = angle * pi/180

    return (1, tan(a), 0, 1, 0, 0)

def mmult(A, B):

    "A postmultiplied by B"

    # I checked this RGB

    # [a0 a2 a4]    [b0 b2 b4]

    # [a1 a3 a5] *  [b1 b3 b5]

    # [      1 ]    [      1 ]

    #

    return (A[0]*B[0] + A[2]*B[1],

            A[1]*B[0] + A[3]*B[1],

            A[0]*B[2] + A[2]*B[3],

            A[1]*B[2] + A[3]*B[3],

            A[0]*B[4] + A[2]*B[5] + A[4],

            A[1]*B[4] + A[3]*B[5] + A[5])

def inverse(A):

    "For A affine 2D represented as 6vec return 6vec version of A**(-1)"

    # I checked this RGB

    det = float(A[0]*A[3] - A[2]*A[1])

    R = [A[3]/det, -A[1]/det, -A[2]/det, A[0]/det]

    return tuple(R+[-R[0]*A[4]-R[2]*A[5],-R[1]*A[4]-R[3]*A[5]])

def zTransformPoint(A,v):

    "Apply the homogenous part of atransformation a to vector v --> A*v"

    return (A[0]*v[0]+A[2]*v[1],A[1]*v[0]+A[3]*v[1])

def transformPoint(A,v):

    "Apply transformation a to vector v --> A*v"

    return (A[0]*v[0]+A[2]*v[1]+A[4],A[1]*v[0]+A[3]*v[1]+A[5])

def transformPoints(matrix, V):

    return list(map(transformPoint, V))

def zTransformPoints(matrix, V):

    return list(map(lambda x,matrix=matrix: zTransformPoint(matrix,x), V))

def _textBoxLimits(text, font, fontSize, leading, textAnchor, boxAnchor):

    w = 0

    for t in text:

        w = max(w,stringWidth(t,font, fontSize))

    h = len(text)*leading

    yt = fontSize

    if boxAnchor[0]=='s':

        yb = -h

        yt = yt - h

    elif boxAnchor[0]=='n':

        yb = 0

    else:

        yb = -h/2.0

        yt = yt + yb

    if boxAnchor[-1]=='e':

        xb = -w

        if textAnchor=='end': xt = 0

        elif textAnchor=='start': xt = -w

        else: xt = -w/2.0

    elif boxAnchor[-1]=='w':

        xb = 0

        if textAnchor=='end': xt = w

        elif textAnchor=='start': xt = 0

        else: xt = w/2.0

    else:

        xb = -w/2.0

        if textAnchor=='end': xt = -xb

        elif textAnchor=='start': xt = xb

        else: xt = 0

    return xb, yb, w, h, xt, yt

def _rotatedBoxLimits( x, y, w, h, angle):

    '''

    Find the corner points of the rotated w x h sized box at x,y

    return the corner points and the min max points in the original space

    '''

    C = zTransformPoints(rotate(angle),((x,y),(x+w,y),(x+w,y+h),(x,y+h)))

    X = [x[0] for x in C]

    Y = [x[1] for x in C]

    return min(X), max(X), min(Y), max(Y), C

class _DrawTimeResizeable:

    '''Addin class to provide the horribleness of _drawTimeResize'''

    def _drawTimeResize(self,w,h):

        if hasattr(self,'_canvas'):

            canvas = self._canvas

            drawing = canvas._drawing

            drawing.width, drawing.height = w, h

            if hasattr(canvas,'_drawTimeResize'):

                canvas._drawTimeResize(w,h)

class _SetKeyWordArgs:

    def __init__(self, keywords={}):

        """In general properties may be supplied to the constructor."""

            setattr(self, key, value)

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

#

#    Helper functions for working out bounds

#

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

def getRectsBounds(rectList):

    # filter out any None objects, e.g. empty groups

    L = [x for x in rectList if x is not None]

    if not L: return None

    xMin, yMin, xMax, yMax = L[0]

    for (x1, y1, x2, y2) in L[1:]:

        if x1 < xMin:

            xMin = x1

        if x2 > xMax:

            xMax = x2

        if y1 < yMin:

            yMin = y1

        if y2 > yMax:

            yMax = y2

    return (xMin, yMin, xMax, yMax)

def _getBezierExtrema(y0,y1,y2,y3):

    '''

    this is used to find if a curveTo path operator has extrema in its range

    The curveTo operator is defined by the points y0, y1, y2, y3

        B(t):=(1-t)^3*y0+3*(1-t)^2*t*y1+3*(1-t)*t^2*y2+t^3*y3

            :=t^3*(y3-3*y2+3*y1-y0)+t^2*(3*y2-6*y1+3*y0)+t*(3*y1-3*y0)+y0

    and is a cubic bezier curve.

    The differential is a quadratic

        t^2*(3*y3-9*y2+9*y1-3*y0)+t*(6*y2-12*y1+6*y0)+3*y1-3*y0

    The extrema must be at real roots, r, of the above which lie in 0<=r<=1

    The quadratic coefficients are

        a=3*y3-9*y2+9*y1-3*y0 b=6*y2-12*y1+6*y0 c=3*y1-3*y0

    or

        a=y3-3*y2+3*y1-y0 b=2*y2-4*y1+2*y0 c=y1-y0  (remove common factor of 3)

    or

        a=y3-3*(y2-y1)-y0 b=2*(y2-2*y1+y0) c=y1-y0

    The returned value is [y0,x1,x2,y3] where if found x1, x2 are any extremals that were found;

    there can be 0, 1 or 2 extremals

    '''

    a=y3-3*(y2-y1)-y0

    b=2*(y2-2*y1+y0)

    c=y1-y0

    Y = [y0] #the set of points

    #standard method to find roots of quadratic

    d = b*b - 4*a*c

    if d>=0:

        d = sqrt(d)

        if b<0: d = -d

        q = -0.5*(b+d)

        R = []

        try:

            R.append(q/a)

        except:

            pass

        try:

            R.append(c/q)

        except:

            pass

        b *= 1.5

        c *= 3

        for t in R:

            if 0<=t<=1:

                #real root in range evaluate spline there and add to X

                Y.append(t*(t*(t*a+b)+c)+y0)

    Y.append(y3)

    return Y

def getPathBounds(points):

    n = len(points)

    f = lambda i,p = points: p[i]

    xs = list(map(f,range(0,n,2)))

    ys = list(map(f,range(1,n,2)))

    return (min(xs), min(ys), max(xs), max(ys))

def getPointsBounds(pointList):

    "Helper function for list of points"

    first = pointList[0]

    if type(first) in (ListType, TupleType):

        xs = [xy[0] for xy in pointList]

        ys = [xy[1] for xy in pointList]

        return (min(xs), min(ys), max(xs), max(ys))

    else:

        return getPathBounds(pointList)

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

#

#    And now the shapes themselves....

#

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

class Shape(_SetKeyWordArgs,_DrawTimeResizeable):

    """Base class for all nodes in the tree. Nodes are simply

    packets of data to be created, stored, and ultimately

    rendered - they don't do anything active.  They provide

    convenience methods for verification but do not

    check attribiute assignments or use any clever setattr

    tricks this time."""

    _attrMap = AttrMap()

    def copy(self):

        """Return a clone of this shape."""

        # implement this in the descendants as they need the right init methods.

        raise NotImplementedError("No copy method implemented for %s" % self.__class__.__name__)

    def getProperties(self,recur=1):

        """Interface to make it easy to extract automatic

        documentation"""

        #basic nodes have no children so this is easy.

        #for more complex objects like widgets you

        #may need to override this.

        props = {}

            if key[0:1] != '_':

                props[key] = value

        return props

    def setProperties(self, props):

        """Supports the bulk setting if properties from,

        for example, a GUI application or a config file."""

        self.__dict__.update(props)

        #self.verify()

    def dumpProperties(self, prefix=""):

        """Convenience. Lists them on standard output.  You

        may provide a prefix - mostly helps to generate code

        samples for documentation."""

        propList = list(self.getProperties().items())

        propList.sort()

        if prefix:

            prefix = prefix + '.'

        for (name, value) in propList:

            print('%s%s = %s' % (prefix, name, value))

    def verify(self):

        """If the programmer has provided the optional

        _attrMap attribute, this checks all expected

        attributes are present; no unwanted attributes

        are present; and (if a checking function is found)

        checks each attribute.  Either succeeds or raises

        an informative exception."""

        if self._attrMap is not None:

                if key[0] != '_':

                    assert key in self._attrMap, "Unexpected attribute %s found in %s" % (key, self)

                assert hasattr(self, attr), "Missing attribute %s from %s" % (attr, self)

                value = getattr(self, attr)

                assert metavalue.validate(value), "Invalid value %s for attribute %s in class %s" % (value, attr, self.__class__.__name__)

    if shapeChecking:

        """This adds the ability to check every attribute assignment as it is made.

        It slows down shapes but is a big help when developing. It does not

        get defined if rl_config.shapeChecking = 0"""

        def __setattr__(self, attr, value):

            """By default we verify.  This could be off

            in some parallel base classes."""

            validateSetattr(self,attr,value)    #from reportlab.lib.attrmap

    def getBounds(self):

        "Returns bounding rectangle of object as (x1,y1,x2,y2)"

        raise NotImplementedError("Shapes and widgets must implement getBounds")

class Group(Shape):

    """Groups elements together.  May apply a transform

    to its contents.  Has a publicly accessible property

    'contents' which may be used to iterate over contents.

    In addition, child nodes may be given a name in which

    case they are subsequently accessible as properties."""

    _attrMap = AttrMap(

        transform = AttrMapValue(isTransform,desc="Coordinate transformation to apply",advancedUsage=1),

        contents = AttrMapValue(isListOfShapes,desc="Contained drawable elements"),

        strokeOverprint = AttrMapValue(isBoolean,desc='Turn on stroke overprinting'),

        fillOverprint = AttrMapValue(isBoolean,desc='Turn on fill overprinting',advancedUsage=1),

        overprintMask = AttrMapValue(isBoolean,desc='overprinting for ordinary CMYK',advancedUsage=1),

        )

    def __init__(self, *elements, **keywords):

        """Initial lists of elements may be provided to allow

        compact definitions in literal Python code.  May or

        may not be useful."""

        # Groups need _attrMap to be an instance rather than

        # a class attribute, as it may be extended at run time.

        self._attrMap = self._attrMap.clone()

        self.contents = []

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

        for elt in elements:

            self.add(elt)

        # this just applies keywords; do it at the end so they

        #don;t get overwritten

        _SetKeyWordArgs.__init__(self, keywords)

    def _addNamedNode(self,name,node):

        'if name is not None add an attribute pointing to node and add to the attrMap'

        if name:

            if name not in list(self._attrMap.keys()):

                self._attrMap[name] = AttrMapValue(isValidChild)

            setattr(self, name, node)

    def add(self, node, name=None):

        """Appends non-None child node to the 'contents' attribute. In addition,

        if a name is provided, it is subsequently accessible by name

        """

        # propagates properties down

        if node is not None:

            assert isValidChild(node), "Can only add Shape or UserNode objects to a Group"

            self.contents.append(node)

            self._addNamedNode(name,node)

    def _nn(self,node):

        self.add(node)

        return self.contents[-1]

    def insert(self, i, n, name=None):

        'Inserts sub-node n in contents at specified location'

        if n is not None:

            assert isValidChild(n), "Can only insert Shape or UserNode objects in a Group"

            if i<0:

                self.contents[i:i] =[n]

            else:

                self.contents.insert(i,n)

            self._addNamedNode(name,n)

    def expandUserNodes(self):

        """Return a new object which only contains primitive shapes."""

        # many limitations - shared nodes become multiple ones,

        obj = isinstance(self,Drawing) and Drawing(self.width,self.height) or Group()

        obj._attrMap = self._attrMap.clone()

        if hasattr(obj,'transform'): obj.transform = self.transform[:]

        self_contents = self.contents

        a = obj.contents.append

        for child in self_contents:

            if isinstance(child, UserNode):

                newChild = child.provideNode()

            elif isinstance(child, Group):

                newChild = child.expandUserNodes()

            else:

                newChild = child.copy()

            a(newChild)

        self._copyNamedContents(obj)

        return obj

    def _explode(self):

        ''' return a fully expanded object'''

        from reportlab.graphics.widgetbase import Widget

        obj = Group()

        if hasattr(obj,'transform'): obj.transform = self.transform[:]

        P = self.contents[:]    # pending nodes

        while P:

            n = P.pop(0)

            if isinstance(n, UserNode):

                P.append(n.provideNode())

            elif isinstance(n, Group):

                n = n._explode()

                if n.transform==(1,0,0,1,0,0):

                    obj.contents.extend(n.contents)

                else:

                    obj.add(n)

            else:

                obj.add(n)

        return obj

    def _copyContents(self,obj):

        for child in self.contents:

            obj.contents.append(child)

    def _copyNamedContents(self,obj,aKeys=None,noCopy=('contents',)):

        from copy import copy

        self_contents = self.contents

        if not aKeys: aKeys = list(self._attrMap.keys())

            if v in self_contents:

                pos = self_contents.index(v)

                setattr(obj, k, obj.contents[pos])

            elif k in aKeys and k not in noCopy:

                setattr(obj, k, copy(v))

    def _copy(self,obj):