"""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, string, types, sys, os
from types import StringType
from operator import getitem

from reportlab.pdfbase.pdfmetrics import stringWidth # for font info
from reportlab.lib.utils import fp_str
from reportlab.lib.colors import black
from reportlab.graphics.renderbase import StateTracker, getStateDelta, Renderer
from reportlab.graphics.shapes import STATE_DEFAULTS, Path, UserNode
from reportlab.graphics.shapes import * # (only for test0)
from reportlab import rl_config
from reportlab.lib.utils import getStringIO

from xml.dom import getDOMImplementation


### some constants ###

sin = math.sin
cos = math.cos
pi = math.pi

LINE_STYLES = 'stroke-width stroke-linecap stroke fill stroke-dasharray'
TEXT_STYLES = 'font-family font-size'


### top-level user function ###

def drawToString(d, showBoundary=rl_config.showBoundary):
    "Returns a SVG as a string in memory, without touching the disk"
    s = getStringIO()
    drawToFile(d, s, showBoundary=showBoundary)
    return s.getvalue()


def drawToFile(d, fn, showBoundary=rl_config.showBoundary):
    c = SVGCanvas((d.width, d.height))
    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(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


### classes ###

class SVGCanvas:
    def __init__(self, size=(300,300)):
        self.verbose = 0
        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 = self._color = None

        implementation = getDOMImplementation('minidom')
        self.doc = implementation.createDocument(None, "svg", None)
        self.svg = self.doc.documentElement
        self.svg.setAttribute("width", str(size[0]))
        self.svg.setAttribute("height", str(self.height))

        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)

        # 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)

        self.groupTree = transformNode(self.doc, "g",
            id="group",
            transform="scale(1,-1) translate(0,-%d)" % self.height,
            style="clip-path: url(#clip)")
        self.svg.appendChild(self.groupTree)
        self.currGroup = self.groupTree


    def save(self, f=None):
        if type(f) is StringType:
            file = open(f, 'w')
        else:
            file = f

        file.write("""\
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20000303 Stylable//EN" "http://www.w3.org/TR/2000/03/WD-SVG-20000303/DTD/svg-20000303-stylable.dtd" >\n""")

        # use = self.doc.createElement('use')
        # use.setAttribute("xlink:href", "#group")
        # use.setAttribute("transform", "scale(1, -1)")
        # self.svg.appendChild(use)

        result = self.svg.toprettyxml(indent="    ")
        file.write(result)

        if file is not f:
            file.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=''):
        str = ''
        include = string.split(include)
        keys = self.style.keys()
        if include:
            #2.1-safe version of the line below follows:
            #keys = filter(lambda k: k in include, keys)
            tmp = []
            for word in keys:
                if word in include:
                    tmp.append(word)
            keys = tmp

        items = []
        for k in keys:
            items.append((k, self.style[k]))
        items = map(lambda i: "%s: %s"%(i[0], i[1]), items)
        str = string.join(items, '; ') + ';'

        return str


    def _escape(self, s):
        """
        return a copy of string s with special characters in postscript strings
        escaped with backslashes.
        Have not handled characters that are converted normally in python strings
        i.e. \n -> newline
        """

        str = string.replace(s, chr(0x5C), r'\\' )
        str = string.replace(str, '(', '\(' )
        str = string.replace(str, ')', '\)')
        return str


    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):
        path = transformNode(self.doc, "path",
            d=self.path, style=self._formatStyle(LINE_STYLES))
        self.currGroup.appendChild(path)
        self.path = ''

        return

        """
        if self._fillColor or self._strokeColor or clip:
            self.code.extend(code)
            if self._fillColor:
                if self._strokeColor or clip:
                    self.code.append("gsave")
                self.setColor(self._fillColor)
                self.code.append("eofill")
                if self._strokeColor or clip:
                    self.code.append("grestore")
            if self._strokeColor != None:
                if clip: self.code.append("gsave")
                self.setColor(self._strokeColor)
                self.code.append("stroke")
                if clip: self.code.append("grestore")
            if clip:
                self.code.append("clip")
                self.code.append("newpath")
        """


    ### 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."""

        join = string.join
        if type(array) in (types.IntType, types.FloatType):
            self.style['stroke-dasharray'] = join(map(str, ([array, phase])), ', ')
        elif type(array) in (types.ListType, types.TupleType) and len(array) > 0:
            assert phase >= 0, "phase is a length in user space"
            self.style['stroke-dasharray'] = join(map(str, (array+[phase])), ', ')


    def setStrokeColor(self, color):
        self._strokeColor = color
        self.setColor(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)


    def setColor(self, color):
        if self._color != color:
            self._color = color


    def setFillColor(self, color):
        self._fillColor = color
        self.setColor(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)


    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, self._fontSize = (font, fontSize)
            self.style['font-family'] = font
            self.style['font-size'] = fontSize


    ### shapes ###

    def rect(self, x1,y1, x2,y2, rx=8, ry=8):
        "Draw a rectangle between x1,y1 and x2,y2."

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

        rect = transformNode(self.doc, "rect",
            x=x1, y=y1, width=x2-x1, height=y2-y1,
            style=self._formatStyle(LINE_STYLES))

        self.currGroup.appendChild(rect)


    def roundRect(self, x1,y1, x2,y2, rx=8, ry=8):
        """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(LINE_STYLES))

        self.currGroup.appendChild(rect)


    def drawString(self, s, x, y, angle=0):
        if self.verbose: print "+++ SVGCanvas.drawString"

        if self._fillColor != None:
            self.setColor(self._fillColor)
            s = self._escape(s)
            st = self._formatStyle(TEXT_STYLES)
            if angle != 0:
               st = st + " rotate(%f %f %f);" % (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))
            content = self.doc.createTextNode(s)
            text.appendChild(content)

            self.currGroup.appendChild(text)


    def comment(self, data):
        "Add a comment."

        comment = self.doc.createComment(data)
        # self.currGroup.appendChild(comment)


    def drawImage(self, image, x1, y1, x2=None, y2=None):
        pass


    def line(self, x1, y1, x2, y2):
        if self._strokeColor != None:
            if 0: # something is wrong with line in my SVG viewer...
                line = transformNode(self.doc, "line",
                    x=x1, y=y1, x2=x2, y2=y2,
                    style=self._formatStyle(LINE_STYLES))
                self.currGroup.appendChild(line)
            path = transformNode(self.doc, "path",
                d="M %f,%f L %f,%f Z" % (x1,y1,x2,y2),
                style=self._formatStyle(LINE_STYLES))
            self.currGroup.appendChild(path)


    def ellipse(self, x1, y1, x2, y2):
        """Draw an orthogonal ellipse inscribed within the rectangle x1,y1,x2,y2.

        These should have x1<x2 and y1<y2.
        """

        ellipse = transformNode(self.doc, "ellipse",
            cx=(x1+x2)/2.0, cy=(y1+y2)/2.0, rx=(x2-x1)/2.0, ry=(y2-y1)/2.0,
            style=self._formatStyle(LINE_STYLES))

        self.currGroup.appendChild(ellipse)


    def circle(self, xc, yc, r):
        circle = transformNode(self.doc, "circle",
            cx=xc, cy=yc, r=r,
            style=self._formatStyle(LINE_STYLES))

        self.currGroup.appendChild(circle)


    def drawCurve(self, x1, y1, x2, y2, x3, y3, x4, y4, closed=0):
        pass
        return

        codeline = '%s m %s curveto'
        data = (fp_str(x1, y1), fp_str(x2, y2, x3, y3, x4, y4))
        if self._fillColor != None:
            self.setColor(self._fillColor)
            self.code.append((codeline % data) + ' eofill')
        if self._strokeColor != None:
            self.setColor(self._strokeColor)
            self.code.append((codeline % data)
                            + ((closed and ' closepath') or '')
                            + ' stroke')


    def drawArc(self, x1,y1, x2,y2, startAng=0, extent=360, fromcenter=0):
        """Draw a partial ellipse inscribed within the rectangle x1,y1,x2,y2.

        Starting at startAng degrees and covering extent degrees. Angles
        start with 0 to the right (+x) and increase counter-clockwise.
        These should have x1<x2 and y1<y2.
        """

        cx, cy = (x1+x2)/2.0, (y1+y2)/2.0
        rx, ry = (x2-x1)/2.0, (y2-y1)/2.0
        mx = rx * cos(startAng*pi/180) + cx
        my = ry * sin(startAng*pi/180) + cy
        ax = rx * cos((startAng+extent)*pi/180) + cx
        ay = ry * sin((startAng+extent)*pi/180) + cy

        str = ''
        if fromcenter:
            str = str + "M %f, %f L %f, %f " % (cx, cy, ax, ay)

        if fromcenter:
            str = str + "A %f, %f %d %d %d %f, %f " % \
              (rx, ry, 0, extent>=180, 0, mx, my)
        else:
            str = str + "M %f, %f A %f, %f %d %d %d %f, %f Z " % \
              (mx, my, rx, ry, 0, extent>=180, 0, mx, my)

        if fromcenter:
            str = str + "L %f, %f Z " % (cx, cy)

        path = transformNode(self.doc, "path",
            d=str, style=self._formatStyle())
        self.currGroup.appendChild(path)


    def polygon(self, points, closed=0):
        assert len(points) >= 2, 'Polygon must have 2 or more points'

        if self._strokeColor != None:
            self.setColor(self._strokeColor)
            pairs = []
            for i in xrange(len(points)):
                pairs.append("%f %f" % (points[i]))
            pts = string.join(pairs, ', ')
            polyline = transformNode(self.doc, "polygon",
                points=pts, style=self._formatStyle(LINE_STYLES))
            self.currGroup.appendChild(polyline)

        # self._fillAndStroke(polyCode)


    def lines(self, lineList, color=None, width=None):
        # print "### lineList", lineList
        return

        if self._strokeColor != None:
            self._setColor(self._strokeColor)
            codeline = '%s m %s l stroke'
            for line in lineList:
                self.code.append(codeline % (fp_str(line[0]), fp_str(line[1])))


    def polyLine(self, points):
        assert len(points) >= 1, 'Polyline must have 1 or more points'

        if self._strokeColor != None:
            self.setColor(self._strokeColor)
            pairs = []
            for i in xrange(len(points)):
                pairs.append("%f %f" % (points[i]))
            pts = string.join(pairs, ', ')
            polyline = transformNode(self.doc, "polyline",
                points=pts, style=self._formatStyle(LINE_STYLES))
            self.currGroup.appendChild(polyline)


    ### groups ###

    def startGroup(self):
        if self.verbose: print "+++ begin SVGCanvas.startGroup"
        currGroup, group = self.currGroup, transformNode(self.doc, "g", transform="")
        currGroup.appendChild(group)
        self.currGroup = group
        if self.verbose: print "+++ end SVGCanvas.startGroup"
        return currGroup

    def endGroup(self,currGroup):
        if self.verbose: print "+++ begin SVGCanvas.endGroup"
        self.currGroup = currGroup
        if self.verbose: print "+++ end SVGCanvas.endGroup"


    def transform(self, a, b, c, d, e, f):
        if self.verbose: print "!!! begin SVGCanvas.transform", a, b, c, d, e, f
        tr = self.currGroup.getAttribute("transform")
        t = 'matrix(%f, %f, %f, %f, %f, %f)' % (a,b,c,d,e,f)
        if (a, b, c, d, e, f) != (1, 0, 0, 1, 0, 0):
            self.currGroup.setAttribute("transform", "%s %s" % (tr, t))


    def translate(self, x, y):
        # probably never used
        print "!!! begin SVGCanvas.translate"
        return

        tr = self.currGroup.getAttribute("transform")
        t = 'translate(%f, %f)' % (x, y)
        self.currGroup.setAttribute("transform", "%s %s" % (tr, t))


    def scale(self, x, y):
        # probably never used
        print "!!! begin SVGCanvas.scale"
        return

        tr = self.groups[-1].getAttribute("transform")
        t = 'scale(%f, %f)' % (x, y)
        self.currGroup.setAttribute("transform", "%s %s" % (tr, t))


    ### paths ###

    def moveTo(self, x, y):
        self.path = self.path + 'M %f %f ' % (x, y)


    def lineTo(self, x, y):
        self.path = self.path + 'L %f %f ' % (x, y)


    def curveTo(self, x1, y1, x2, y2, x3, y3):
        self.path = self.path + 'C %f %f %f %f %f %f ' % (x1, y1, x2, y2, x3, y3)


    def closePath(self):
        self.path = self.path + 'Z '

    def saveState(self):
        pass

    def restoreState(self):
        pass

class _SVGRenderer(Renderer):
    """This draws onto an SVG document.
    """

    def __init__(self):
        self._tracker = StateTracker()
        self.verbose = 0

    def drawNode(self, node):
        """This is the recursive method called for each node in the tree.
        """

        if self.verbose: print "### begin _SVGRenderer.drawNode"

        self._canvas.comment('begin node %s'%`node`)
        color = self._canvas._color
        if not (isinstance(node, Path) and node.isClipPath):
            pass # self._canvas.saveState()

        #apply state changes
        deltas = getStateDelta(node)
        self._tracker.push(deltas)
        self.applyStateChanges(deltas, {})

        #draw the object, or recurse
        self.drawNodeDispatcher(node)

        rDeltas = self._tracker.pop()
        if not (isinstance(node, Path) and node.isClipPath):
            pass # self._canvas.restoreState()
        self._canvas.comment('end node %s'%`node`)
        self._canvas._color = color

        #restore things we might have lost (without actually doing anything).
        for k, v in rDeltas.items():
            if self._restores.has_key(k):
                setattr(self._canvas,self._restores[k],v)

        if self.verbose: print "### end _SVGRenderer.drawNode"

    _restores = {'strokeColor':'_strokeColor','strokeWidth': '_lineWidth','strokeLineCap':'_lineCap',
                'strokeLineJoin':'_lineJoin','fillColor':'_fillColor','fontName':'_font',
                'fontSize':'_fontSize'}


    def drawGroup(self, group):
        if self.verbose: print "### begin _SVGRenderer.drawGroup"

        currGroup = self._canvas.startGroup()
        a, b, c, d, e, f = self._tracker.getCTM()
        for childNode in group.getContents():
            if isinstance(childNode, UserNode):
                node2 = childNode.provideNode()
            else:
                node2 = childNode
            self.drawNode(node2)
        self._canvas.transform(a, b, c, d, e, f)
        self._canvas.endGroup(currGroup)

        if self.verbose: print "### end _SVGRenderer.drawGroup"


    def drawRect(self, rect):
        if rect.rx == rect.ry == 0:
            #plain old rectangle
            self._canvas.rect(
                    rect.x, rect.y,
                    rect.x+rect.width, rect.y+rect.height)
        else:
            #cheat and assume ry = rx; better to generalize
            #pdfgen roundRect function.  TODO
            self._canvas.roundRect(
                    rect.x, rect.y,
                    rect.x+rect.width, rect.y+rect.height,
                    rect.rx, rect.ry
                    )


    def drawString(self, stringObj):
        if self._canvas._fillColor:
            S = self._tracker.getState()
            text_anchor, x, y, text = S['textAnchor'], stringObj.x, stringObj.y, stringObj.text
            if not text_anchor in ['start', 'inherited']:
                font, fontSize = S['fontName'], S['fontSize']
                textLen = stringWidth(text, font,fontSize)
                if text_anchor=='end':
                    x = x-textLen
                elif text_anchor=='middle':
                    x = x - textLen/2
                else:
                    raise ValueError, 'bad value for text_anchor ' + str(text_anchor)
            self._canvas.drawString(text,x,y)


    def drawLine(self, line):
        if self._canvas._strokeColor:
            self._canvas.line(line.x1, line.y1, line.x2, line.y2)


    def drawCircle(self, circle):
        self._canvas.circle( circle.cx, circle.cy, circle.r)


    def drawWedge(self, wedge):
        centerx, centery, radius, startangledegrees, endangledegrees = \
         wedge.centerx, wedge.centery, wedge.radius, wedge.startangledegrees, wedge.endangledegrees
        yradius = wedge.yradius or wedge.radius
        (x1, y1) = (centerx-radius, centery-yradius)
        (x2, y2) = (centerx+radius, centery+yradius)
        extent = endangledegrees - startangledegrees
        self._canvas.drawArc(x1, y1, x2, y2, startangledegrees, extent, fromcenter=1)


    def drawPolyLine(self, p):
        if self._canvas._strokeColor:
            self._canvas.polyLine(_pointsFromList(p.points))


    def drawEllipse(self, ellipse):
        #need to convert to pdfgen's bounding box representation
        x1 = ellipse.cx - ellipse.rx
        x2 = ellipse.cx + ellipse.rx
        y1 = ellipse.cy - ellipse.ry
        y2 = ellipse.cy + ellipse.ry
        self._canvas.ellipse(x1,y1,x2,y2)


    def drawPolygon(self, p):
        self._canvas.polygon(_pointsFromList(p.points), closed=1)


    def drawPath(self, path):
        # print "### drawPath", path.points
        from reportlab.graphics.shapes import _renderPath
        c = self._canvas
        drawFuncs = (c.moveTo, c.lineTo, c.curveTo, c.closePath)
        isClosed = _renderPath(path, drawFuncs)
        if not isClosed:
            c._fillColor = None
        c._fillAndStroke([], clip=path.isClipPath)


    def applyStateChanges(self, delta, newState):
        """This takes a set of states, and outputs the operators
        needed to set those properties"""

        for key, value in delta.items():
            if key == 'transform':
                pass
                #self._canvas.transform(value[0], value[1], value[2], value[3], value[4], value[5])
            elif key == 'strokeColor':
                self._canvas.setStrokeColor(value)
            elif key == 'strokeWidth':
                self._canvas.setLineWidth(value)
            elif key == 'strokeLineCap':  #0,1,2
                self._canvas.setLineCap(value)
            elif key == 'strokeLineJoin':
                self._canvas.setLineJoin(value)
            elif key == 'strokeDashArray':
                if value:
                    self._canvas.setDash(value)
                else:
                    self._canvas.setDash()
            elif key == 'fillColor':
                self._canvas.setFillColor(value)
            elif key in ['fontSize', 'fontName']:
                fontname = delta.get('fontName', self._canvas._font)
                fontsize = delta.get('fontSize', self._canvas._fontSize)
                self._canvas.setFont(fontname, fontsize)




def test0(outdir='svgout'):
    # print all drawings and their doc strings from the test
    # file
    if not os.path.isdir(outdir):
        os.mkdir(outdir)
    #grab all drawings from the test module
    from reportlab.graphics import testshapes
    drawings = []

    for funcname in dir(testshapes):
        #if funcname[0:11] == 'getDrawing2':
        #    print 'hacked to only show drawing 2'
        if funcname[0:10] == 'getDrawing':
            drawing = eval('testshapes.' + funcname + '()')
            docstring = eval('testshapes.' + funcname + '.__doc__')
            drawings.append((drawing, docstring))

    # return

    i = 0
    for (d, docstring) in drawings:
        filename = outdir + os.sep + 'renderSVG_%d.svg' % i
        drawToFile(d, filename)
        # print 'saved', filename
        i = i + 1


def test1():
    from reportlab.graphics.testshapes import getDrawing01
    d = getDrawing01()
    drawToFile(d, "svgout/test.svg")


def test2():
    from reportlab.lib.corp import RL_CorpLogo
    from reportlab.graphics.shapes import Drawing

    rl = RL_CorpLogo()
    d = Drawing(rl.width,rl.height)
    d.add(rl)
    drawToFile(d, "svgout/corplogo.svg")


if __name__=='__main__':
    test0()
    test1()
    test2()