Removed reportlab

bzr revid: pinky-6fa6b5bb1cfc5dd54307cd22a31f527d28d61e05

1 files changed, 0 insertions, 828 deletions

diff --git a/bin/reportlab/graphics/renderSVG.py b/bin/reportlab/graphics/renderSVG.py
deleted file mode 100644
index 73aaddfc16d..00000000000
--- a/bin/reportlab/graphics/renderSVG.py
+++ /dev/null
@@ -1,828 +0,0 @@
-"""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, renderScaledDrawing
-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):
-    d = renderScaledDrawing(d)
-    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(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
-
-
-### 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 drawCentredString(self, s, x, y, angle=0,text_anchor='middle'):
-        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.
-                else:
-                    raise ValueError, 'bad value for text_anchor ' + str(text_anchor)
-        self.drawString(x,y,text,angle=angle)
-
-    def drawRightString(self, text, x, y, angle=0):
-        self.drawCentredString(text,x,y,angle=angle,text_anchor='end')
-
-    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()