__doc__="""An experimental SVG renderer for the ReportLab graphics framework.

This will create SVG code from the ReportLab Graphics API (RLG).

To read existing SVG code and convert it into ReportLab graphics

objects download the svglib module here:

  http://python.net/~gherman/#svglib

"""

import math, types, sys, os, codecs, base64

from operator import getitem

from reportlab.pdfbase.pdfmetrics import stringWidth # for font info

from reportlab.lib.rl_accel import fp_str

from reportlab.lib.colors import black

from reportlab.lib.utils import asNative, getBytesIO

from reportlab.graphics.renderbase import StateTracker, getStateDelta, Renderer, renderScaledDrawing

from reportlab.graphics.shapes import STATE_DEFAULTS, Path, UserNode

from reportlab.graphics.shapes import * # (only for test0)

from reportlab import rl_config, ascii

from reportlab.lib.utils import getStringIO, RLString, isPy3, isUnicode, isBytes

from reportlab.pdfgen.canvas import FILL_EVEN_ODD, FILL_NON_ZERO

from xml.dom import getDOMImplementation

### some constants ###

sin = math.sin

cos = math.cos

pi = math.pi

AREA_STYLES = 'stroke-width stroke-linecap stroke stroke-opacity fill fill-opacity stroke-dasharray id'.split()

LINE_STYLES = 'stroke-width stroke-linecap stroke stroke-opacity stroke-dasharray id'.split()

TEXT_STYLES = 'font-family font-weight font-style font-variant font-size id'.split()

### top-level user function ###

def drawToString(d, showBoundary=rl_config.showBoundary,**kwds):

    "Returns a SVG as a string in memory, without touching the disk"

    s = getStringIO()

    drawToFile(d, s, showBoundary=showBoundary,**kwds)

    return s.getvalue()

def drawToFile(d, fn, showBoundary=rl_config.showBoundary,**kwds):

    d = renderScaledDrawing(d)

    c = SVGCanvas((d.width, d.height),**kwds)

    draw(d, c, 0, 0, showBoundary=showBoundary)

    c.save(fn)

def draw(drawing, canvas, x=0, y=0, showBoundary=rl_config.showBoundary):

    """As it says."""

    r = _SVGRenderer()

    r.draw(renderScaledDrawing(drawing), canvas, x, y, showBoundary=showBoundary)

### helper functions ###

def _pointsFromList(L):

    """

    given a list of coordinates [x0, y0, x1, y1....]

    produce a list of points [(x0,y0), (y1,y0),....]

    """

    P=[]

    for i in range(0,len(L), 2):

        P.append((L[i], L[i+1]))

    return P

def transformNode(doc, newTag, node=None, **attrDict):

    """Transform a DOM node into new node and copy selected attributes.

    Creates a new DOM node with tag name 'newTag' for document 'doc'

    and copies selected attributes from an existing 'node' as provided

    in 'attrDict'. The source 'node' can be None. Attribute values will

    be converted to strings.

    E.g.

        n = transformNode(doc, "node1", x="0", y="1")

        -> DOM node for <node1 x="0" y="1"/>

        n = transformNode(doc, "node1", x=0, y=1+1)

        -> DOM node for <node1 x="0" y="2"/>

        n = transformNode(doc, "node1", node0, x="x0", y="x0", zoo=bar())

        -> DOM node for <node1 x="[node0.x0]" y="[node0.y0]" zoo="[bar()]"/>

    """

    newNode = doc.createElement(newTag)

    for newAttr, attr in attrDict.items():

        sattr =  str(attr)

        if not node:

            newNode.setAttribute(newAttr, sattr)

        else:

            attrVal = node.getAttribute(sattr)

            newNode.setAttribute(newAttr, attrVal or sattr)

    return newNode

class EncodedWriter(list):

    '''

    EncodedWriter(encoding) assumes .write will be called with

    either unicode or utf8 encoded bytes. it will accumulate

    unicode

    '''

    BOMS =  {

        'utf-32':codecs.BOM_UTF32,

        'utf-32-be':codecs.BOM_UTF32_BE,

        'utf-32-le':codecs.BOM_UTF32_LE,

        'utf-16':codecs.BOM_UTF16,

        'utf-16-be':codecs.BOM_UTF16_BE,

        'utf-16-le':codecs.BOM_UTF16_LE,

        }

    def __init__(self,encoding,bom=False):

        list.__init__(self)

        self.encoding = encoding = codecs.lookup(encoding).name

        if bom and '16' in encoding or '32' in encoding:

            self.write(self.BOMS[encoding])

    def write(self,u):

        if isBytes(u):

            try:

                 u = u.decode('utf-8')

            except:

                et, ev, tb = sys.exc_info()

                ev = str(ev)

                del et, tb

                raise ValueError("String %r not encoded as 'utf-8'\nerror=%s" % (u,ev))

        elif not isUnicode(u):

            raise ValueError("EncodedWriter.write(%s) argument should be 'utf-8' bytes or str" % ascii(u))

        self.append(u)

    def getvalue(self):

        r = ''.join(self)

        del self[:]

        return r

_fillRuleMap = {

        FILL_NON_ZERO: 'nonzero',

        'non-zero': 'nonzero',

        'nonzero': 'nonzero',

        FILL_EVEN_ODD: 'evenodd',

        'even-odd': 'evenodd',

        'evenodd': 'evenodd',

        }

### classes ###

class SVGCanvas:

    def __init__(self, size=(300,300), encoding='utf-8', verbose=0, bom=False, **kwds):

        '''

        verbose = 0 >0 means do verbose stuff

        useClip = False True means don't use a clipPath definition put the global clip into the clip property

                        to get around an issue with safari

        extraXmlDecl = ''   use to add extra xml declarations

        scaleGroupId = ''   id of an extra group to add around the drawing to allow easy scaling

        svgAttrs = {}       dictionary of attributes to be applied to the svg tag itself

        '''

        self.verbose = verbose

        self.encoding = codecs.lookup(encoding).name

        self.bom = bom

        useClip = kwds.pop('useClip',False)

        self.fontHacks = kwds.pop('fontHacks',{})

        self.extraXmlDecl = kwds.pop('extraXmlDecl','')

        scaleGroupId = kwds.pop('scaleGroupId','')

        self._fillMode = FILL_EVEN_ODD

        self.width, self.height = self.size = size

        # self.height = size[1]

        self.code = []

        self.style = {}

        self.path = ''

        self._strokeColor = self._fillColor = self._lineWidth = \

            self._font = self._fontSize = self._lineCap = \

            self._lineJoin = None

        if kwds.pop('use_fp_str',False):

            self.fp_str = fp_str

        else:

            self.fp_str = lambda *args: (' '.join(len(args)*['%f'])) % args

        self.cfp_str = lambda *args: self.fp_str(*args).replace(' ',',')

        implementation = getDOMImplementation('minidom')

        #Based on official example here http://www.w3.org/TR/SVG10/linking.html want:

        #<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN" 

        #  "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">

        #Thus,

        #doctype = implementation.createDocumentType("svg",

        #          "-//W3C//DTD SVG 20010904//EN",

        #          "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd")

        #

        #However, putting that example through http://validator.w3.org/ recommends:

        #<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" 

        #  "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">

        #So we'll use that for our SVG 1.0 output.

        doctype = implementation.createDocumentType("svg",

                  "-//W3C//DTD SVG 1.0//EN",

                  "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd")

        self.doc = implementation.createDocument(None,"svg",doctype)

        self.svg = self.doc.documentElement

        svgAttrs = dict(

                    width = str(size[0]),

                    height=str(self.height),

                    preserveAspectRatio="xMinYMin meet",

                    viewBox="0 0 %d %d" % (self.width, self.height),

                    #baseProfile = "full",  #disliked in V 1.0

                    #these suggested by Tim Roberts, as updated by peter@maubp.freeserve.co.uk 

                    xmlns="http://www.w3.org/2000/svg",

                    version="1.0",

                    )

        svgAttrs['fill-rule'] = _fillRuleMap[self._fillMode]

        svgAttrs["xmlns:xlink"] = "http://www.w3.org/1999/xlink"

        svgAttrs.update(kwds.pop('svgAttrs',{}))

        for k,v in svgAttrs.items():

            self.svg.setAttribute(k,v)

        title = self.doc.createElement('title')

        text = self.doc.createTextNode('...')

        title.appendChild(text)

        self.svg.appendChild(title)

        desc = self.doc.createElement('desc')

        text = self.doc.createTextNode('...')

        desc.appendChild(text)

        self.svg.appendChild(desc)

        self.setFont(STATE_DEFAULTS['fontName'], STATE_DEFAULTS['fontSize'])

        self.setStrokeColor(STATE_DEFAULTS['strokeColor'])

        self.setLineCap(2)

        self.setLineJoin(0)

        self.setLineWidth(1)

        if not useClip:

            # Add a rectangular clipping path identical to view area.

            clipPath = transformNode(self.doc, "clipPath", id="clip")

            clipRect = transformNode(self.doc, "rect", x=0, y=0,

                width=self.width, height=self.height)

            clipPath.appendChild(clipRect)

            self.svg.appendChild(clipPath)

            gtkw = dict(style="clip-path: url(#clip)")

        else:

            gtkw = dict(clip="0 0 %d %d" % (self.width,self.height))

        self.groupTree = transformNode(self.doc, "g",

            id="group",

            transform="scale(1,-1) translate(0,-%d)" % self.height,

            **gtkw

            )

        if scaleGroupId:

            self.scaleTree = transformNode(self.doc, "g", id=scaleGroupId, transform="scale(1,1)")

            self.scaleTree.appendChild(self.groupTree)

            self.svg.appendChild(self.scaleTree)

        else:

            self.svg.appendChild(self.groupTree)

        self.currGroup = self.groupTree

    def save(self, fn=None):

        writer = EncodedWriter(self.encoding,bom=self.bom)

        self.doc.writexml(writer,addindent="\t",newl="\n",encoding=self.encoding)

        if hasattr(fn,'write'):

            f = fn

        else:

            if isPy3:

                f = open(fn, 'w',encoding=self.encoding)

            else:

                f = open(fn, 'w')

        svg = writer.getvalue()

        exd = self.extraXmlDecl

        if exd:

            svg = svg.replace('?>','?>'+exd)

        f.write(svg if isPy3 else svg.encode(self.encoding))

        if f is not fn:

            f.close()

    ### helpers ###

    def NOTUSED_stringWidth(self, s, font=None, fontSize=None):

        """Return the logical width of the string if it were drawn

        in the current font (defaults to self.font).

        """

        font = font or self._font

        fontSize = fontSize or self._fontSize

        return stringWidth(s, font, fontSize)

    def _formatStyle(self, include=[], exclude='',**kwds):

        style = self.style.copy()

        style.update(kwds)

        keys = list(style.keys())

        if include:

            keys = [k for k in keys if k in include]

        if exclude:

            exclude = exclude.split()

            items = [k+': '+str(style[k]) for k in keys if k not in exclude]

        else:

            items = [k+': '+str(style[k]) for k in keys]

        return '; '.join(items) + ';'

    def _escape(self, s):

        '''I don't think this was ever needed; seems to have been copied from renderPS'''

        return s

    def _genArcCode(self, x1, y1, x2, y2, startAng, extent):

        """Calculate the path for an arc inscribed in rectangle defined

        by (x1,y1),(x2,y2)."""

        return

        #calculate semi-minor and semi-major axes of ellipse

        xScale = abs((x2-x1)/2.0)

        yScale = abs((y2-y1)/2.0)

        #calculate centre of ellipse

        x, y = (x1+x2)/2.0, (y1+y2)/2.0

        codeline = 'matrix currentmatrix %s %s translate %s %s scale 0 0 1 %s %s %s setmatrix'

        if extent >= 0:

            arc='arc'

        else:

            arc='arcn'

        data = (x,y, xScale, yScale, startAng, startAng+extent, arc)

        return codeline % data

    def _fillAndStroke(self, code, clip=0, link_info=None,styles=AREA_STYLES,fillMode=None):

        xtra = {}

        if fillMode:

            xtra['fill-rule'] = _fillRuleName(fillMode)

        path = transformNode(self.doc, "path",

            d=self.path, style=self._formatStyle(styles),

            )

        if link_info :

            path = self._add_link(path, link_info)

        self.currGroup.appendChild(path)

        self.path = ''

    ### styles ###

    def setLineCap(self, v):

        vals = {0:'butt', 1:'round', 2:'square'}

        if self._lineCap != v:

            self._lineCap = v

            self.style['stroke-linecap'] = vals[v]

    def setLineJoin(self, v):

        vals = {0:'miter', 1:'round', 2:'bevel'}

        if self._lineJoin != v:

            self._lineJoin = v

            self.style['stroke-linecap'] = vals[v]

    def setDash(self, array=[], phase=0):

        """Two notations. Pass two numbers, or an array and phase."""

        if isinstance(array,(float,int)):

            self.style['stroke-dasharray'] = ', '.join(map(str, ([array, phase])))

        elif isinstance(array,(tuple,list)) and len(array) > 0:

            assert phase >= 0, "phase is a length in user space"

    def setStrokeColor(self, color):

        self._strokeColor = color

        if color == None:

            self.style['stroke'] = 'none'

        else:

            r, g, b = color.red, color.green, color.blue

            self.style['stroke'] = 'rgb(%d%%,%d%%,%d%%)' % (r*100, g*100, b*100)

            alpha = color.normalizedAlpha

            if alpha!=1:

                self.style['stroke-opacity'] = '%s' % alpha

            elif 'stroke-opacity' in self.style:

                del self.style['stroke-opacity']

    def setFillColor(self, color):

        self._fillColor = color

        if color == None:

            self.style['fill'] = 'none'

        else:

            r, g, b = color.red, color.green, color.blue

            self.style['fill'] = 'rgb(%d%%,%d%%,%d%%)' % (r*100, g*100, b*100)

            alpha = color.normalizedAlpha

            if alpha!=1:

                self.style['fill-opacity'] = '%s' % alpha

            elif 'fill-opacity' in self.style:

                del self.style['fill-opacity']

    def setFillMode(self, v):

        self._fillMode = v

        self.style['fill-rule'] = _fillRuleMap[v]

    def setLineWidth(self, width):

        if width != self._lineWidth:

            self._lineWidth = width

            self.style['stroke-width'] = width

    def setFont(self, font, fontSize):

        if self._font != font or self._fontSize != fontSize:

            self._font = font

            self._fontSize = fontSize

            style = self.style

            for k in TEXT_STYLES:

                if k in style:

                    del style[k]

            svgAttrs = self.fontHacks[font] if font in self.fontHacks else {}

            if isinstance(font,RLString):

                svgAttrs.update(iter(font.svgAttrs.items()))

            if svgAttrs:

                for k,v in svgAttrs.items():

                    a = 'font-'+k

                    if a in TEXT_STYLES:

                        style[a] = v

            if 'font-family' not in style:

                style['font-family'] = font

            style['font-size'] = '%spx' % fontSize

    def _add_link(self, dom_object, link_info) :

        assert isinstance(link_info, dict)

        link = transformNode(self.doc, "a", **link_info)

        link.appendChild(dom_object)

        return link

    ### shapes ###

    def rect(self, x1,y1, x2,y2, rx=8, ry=8, link_info=None, **_svgAttrs):

        "Draw a rectangle between x1,y1 and x2,y2."

        if self.verbose: print("+++ SVGCanvas.rect")

        x = min(x1,x2)

        y = min(y1,y2)

        kwds = {}

        rect = transformNode(self.doc, "rect",

            x=x, y=y, width=max(x1,x2)-x, height=max(y1,y2)-y,

            style=self._formatStyle(AREA_STYLES),**_svgAttrs)

        if link_info :

            rect = self._add_link(rect, link_info)

        self.currGroup.appendChild(rect)

    def roundRect(self, x1,y1, x2,y2, rx=8, ry=8, link_info=None, **_svgAttrs):

        """Draw a rounded rectangle between x1,y1 and x2,y2.

        Corners inset as ellipses with x-radius rx and y-radius ry.

        These should have x1<x2, y1<y2, rx>0, and ry>0.

        """

        rect = transformNode(self.doc, "rect",

            x=x1, y=y1, width=x2-x1, height=y2-y1, rx=rx, ry=ry,

            style=self._formatStyle(AREA_STYLES), **_svgAttrs)

        if link_info:

            rect = self._add_link(rect, link_info)

        self.currGroup.appendChild(rect)

    def drawString(self, s, x, y, angle=0, link_info=None,**_svgAttrs):

        s = asNative(s)

        if self.verbose: print("+++ SVGCanvas.drawString")

        if self._fillColor != None:

            s = self._escape(s)

            st = self._formatStyle(TEXT_STYLES)

            if angle != 0:

               st = st + " rotate(%s);" % self.fp_str(angle, x, y)

            st = st + " fill: %s;" % self.style['fill']

            text = transformNode(self.doc, "text",

                x=x, y=y, style=st,

                transform="translate(0,%d) scale(1,-1)" % (2*y),

                **_svgAttrs

                )

            content = self.doc.createTextNode(s)

            text.appendChild(content)

            if link_info:

                text = self._add_link(text, link_info)

            self.currGroup.appendChild(text)

    def drawCentredString(self, s, x, y, angle=0, text_anchor='middle', link_info=None):

        if self.verbose: print("+++ SVGCanvas.drawCentredString")

        if self._fillColor != None:

            if not text_anchor in ['start', 'inherited']:

                textLen = stringWidth(s,self._font,self._fontSize)

                if text_anchor=='end':

                    x -= textLen

                elif text_anchor=='middle':

                    x -= textLen/2.

                elif text_anchor=='numeric':

                    x -= numericXShift(text_anchor,s,textLen,self._font,self._fontSize)

                else:

                    raise ValueError('bad value for text_anchor ' + str(text_anchor))

        self.drawString(s,x,y,angle=angle, link_info=link_info)

    def drawRightString(self, text, x, y, angle=0, link_info=None):

        self.drawCentredString(text,x,y,angle=angle,text_anchor='end', link_info=link_info)