projects.mako.cc - yourule/blob - SVGdraw.py

   1 #!/usr/bin/env python
   2 ##Copyright (c) 2002, Fedor Baart & Hans de Wit (Stichting Farmaceutische Kengetallen)
   3 ##All rights reserved.
   4 ##
   5 ##Redistribution and use in source and binary forms, with or without modification,
   6 ##are permitted provided that the following conditions are met:
   7 ##
   8 ##Redistributions of source code must retain the above copyright notice, this
   9 ##list of conditions and the following disclaimer.
  10 ##
  11 ##Redistributions in binary form must reproduce the above copyright notice,
  12 ##this list of conditions and the following disclaimer in the documentation and/or
  13 ##other materials provided with the distribution.
  14 ##
  15 ##Neither the name of the Stichting Farmaceutische Kengetallen nor the names of
  16 ##its contributors may be used to endorse or promote products derived from this
  17 ##software without specific prior written permission.
  18 ##
  19 ##THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20 ##AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21 ##IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22 ##DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  23 ##FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24 ##DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25 ##SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26 ##CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27 ##OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 ##OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 ##Thanks to Gerald Rosennfellner for his help and useful comments.
  31
  32 __doc__="""Use SVGdraw to generate your SVGdrawings.
  33
  34 SVGdraw uses an object model drawing and a method toXML to create SVG graphics
  35 by using easy to use classes and methods usualy you start by creating a drawing eg
  36
  37     d=drawing()
  38     #then you create a SVG root element
  39     s=svg()
  40     #then you add some elements eg a circle and add it to the svg root element
  41     c=circle()
  42     #you can supply attributes by using named arguments.
  43     c=circle(fill='red',stroke='blue')
  44     #or by updating the attributes attribute:
  45     c.attributes['stroke-width']=1
  46     s.addElement(c)
  47     #then you add the svg root element to the drawing
  48     d.setSVG(s)
  49     #and finaly you xmlify the drawing
  50     d.toXml()
  51
  52
  53 this results in the svg source of the drawing, which consists of a circle
  54 on a white background. Its as easy as that;)
  55 This module was created using the SVG specification of www.w3c.org and the
  56 O'Reilly (www.oreilly.com) python books as information sources. A svg viewer
  57 is available from www.adobe.com"""
  58
  59 __version__="1.0"
  60
  61 # there are two possibilities to generate svg:
  62 # via a dom implementation and directly using <element>text</element> strings
  63 # the latter is way faster (and shorter in coding)
  64 # the former is only used in debugging svg programs
  65 # maybe it will be removed alltogether after a while
  66 # with the following variable you indicate whether to use the dom implementation
  67 # Note that PyXML is required for using the dom implementation.
  68 # It is also possible to use the standard minidom. But I didn't try that one.
  69 # Anyway the text based approach is about 60 times faster than using the full dom implementation.
  70 use_dom_implementation=0
  71
  72
  73 import exceptions
  74 if use_dom_implementation<>0:
  75     try:
  76         from xml.dom import implementation
  77         from xml.dom.ext import PrettyPrint
  78     except:
  79         raise exceptions.ImportError, "PyXML is required for using the dom implementation"
  80 #The implementation is used for the creating the XML document.
  81 #The prettyprint module is used for converting the xml document object to a xml file
  82
  83 import sys
  84 assert sys.version_info[0]>=2
  85 if sys.version_info[1]<2:
  86     True=1
  87     False=0
  88     file=open
  89
  90 sys.setrecursionlimit=50
  91 #The recursion limit is set conservative so mistakes like s=svg() s.addElement(s)
  92 #won't eat up too much processor time.
  93
  94 #the following code is pasted form xml.sax.saxutils
  95 #it makes it possible to run the code without the xml sax package installed
  96 #To make it possible to have <rubbish> in your text elements, it is necessary to escape the texts
  97 def _escape(data, entities={}):
  98     """Escape &, <, and > in a string of data.
  99
 100     You can escape other strings of data by passing a dictionary as
 101     the optional entities parameter.  The keys and values must all be
 102     strings; each key will be replaced with its corresponding value.
 103     """
 104     data = data.replace("&", "&amp;")
 105     data = data.replace("<", "&lt;")
 106     data = data.replace(">", "&gt;")
 107     for chars, entity in entities.items():
 108         data = data.replace(chars, entity)
 109     return data
 110
 111 def _quoteattr(data, entities={}):
 112     """Escape and quote an attribute value.
 113
 114     Escape &, <, and > in a string of data, then quote it for use as
 115     an attribute value.  The \" character will be escaped as well, if
 116     necessary.
 117
 118     You can escape other strings of data by passing a dictionary as
 119     the optional entities parameter.  The keys and values must all be
 120     strings; each key will be replaced with its corresponding value.
 121     """
 122     data = _escape(data, entities)
 123     if '"' in data:
 124         if "'" in data:
 125             data = '"%s"' % data.replace('"', "&quot;")
 126         else:
 127             data = "'%s'" % data
 128     else:
 129         data = '"%s"' % data
 130     return data
 131
 132
 133
 134 def _xypointlist(a):
 135     """formats a list of xy pairs"""
 136     s=''
 137     for e in a: #this could be done more elegant
 138         s+=str(e)[1:-1] +'  '
 139     return s
 140
 141 def _viewboxlist(a):
 142     """formats a tuple"""
 143     s=''
 144     for e in a:
 145         s+=str(e)+' '
 146     return s
 147
 148 def _pointlist(a):
 149     """formats a list of numbers"""
 150     return str(a)[1:-1]
 151
 152 class pathdata:
 153     """class used to create a pathdata object which can be used for a path.
 154     although most methods are pretty straightforward it might be useful to look at the SVG specification."""
 155     #I didn't test the methods below.
 156     def __init__(self,x=None,y=None):
 157         self.path=[]
 158         if x is not None and y is not None:
 159             self.path.append('M '+str(x)+' '+str(y))
 160     def closepath(self):
 161         """ends the path"""
 162         self.path.append('z')
 163     def move(self,x,y):
 164         """move to absolute"""
 165         self.path.append('M '+str(x)+' '+str(y))
 166     def relmove(self,x,y):
 167         """move to relative"""
 168         self.path.append('m '+str(x)+' '+str(y))
 169     def line(self,x,y):
 170         """line to absolute"""
 171         self.path.append('L '+str(x)+' '+str(y))
 172     def relline(self,x,y):
 173         """line to relative"""
 174         self.path.append('l '+str(x)+' '+str(y))
 175     def hline(self,x):
 176         """horizontal line to absolute"""
 177         self.path.append('H'+str(x))
 178     def relhline(self,x):
 179         """horizontal line to relative"""
 180         self.path.append('h'+str(x))
 181     def vline(self,y):
 182         """verical line to absolute"""
 183         self.path.append('V'+str(y))
 184     def relvline(self,y):
 185         """vertical line to relative"""
 186         self.path.append('v'+str(y))
 187     def bezier(self,x1,y1,x2,y2,x,y):
 188         """bezier with xy1 and xy2 to xy absolut"""
 189         self.path.append('C'+str(x1)+','+str(y1)+' '+str(x2)+','+str(y2)+' '+str(x)+','+str(y))
 190     def relbezier(self,x1,y1,x2,y2,x,y):
 191         """bezier with xy1 and xy2 to xy relative"""
 192         self.path.append('c'+str(x1)+','+str(y1)+' '+str(x2)+','+str(y2)+' '+str(x)+','+str(y))
 193     def smbezier(self,x2,y2,x,y):
 194         """smooth bezier with xy2 to xy absolut"""
 195         self.path.append('S'+str(x2)+','+str(y2)+' '+str(x)+','+str(y))
 196     def relsmbezier(self,x2,y2,x,y):
 197         """smooth bezier with xy2 to xy relative"""
 198         self.path.append('s'+str(x2)+','+str(y2)+' '+str(x)+','+str(y))
 199     def qbezier(self,x1,y1,x,y):
 200         """quadratic bezier with xy1 to xy absolut"""
 201         self.path.append('Q'+str(x1)+','+str(y1)+' '+str(x)+','+str(y))
 202     def relqbezier(self,x1,y1,x,y):
 203         """quadratic bezier with xy1 to xy relative"""
 204         self.path.append('q'+str(x1)+','+str(y1)+' '+str(x)+','+str(y))
 205     def smqbezier(self,x,y):
 206         """smooth quadratic bezier to xy absolut"""
 207         self.path.append('T'+str(x)+','+str(y))
 208     def relsmqbezier(self,x,y):
 209         """smooth quadratic bezier to xy relative"""
 210         self.path.append('t'+str(x)+','+str(y))
 211     def ellarc(self,rx,ry,xrot,laf,sf,x,y):
 212         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy absolut"""
 213         self.path.append('A'+str(rx)+','+str(ry)+' '+str(xrot)+' '+str(laf)+' '+str(sf)+' '+str(x)+' '+str(y))
 214     def relellarc(self,rx,ry,xrot,laf,sf,x,y):
 215         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy relative"""
 216         self.path.append('a'+str(rx)+','+str(ry)+' '+str(xrot)+' '+str(laf)+' '+str(sf)+' '+str(x)+' '+str(y))
 217     def __repr__(self):
 218         return ' '.join(self.path)
 219
 220
 221
 222
 223 class SVGelement:
 224     """SVGelement(type,attributes,elements,text,namespace,**args)
 225     Creates a arbitrary svg element and is intended to be subclassed not used on its own.
 226     This element is the base of every svg element it defines a class which resembles
 227     a xml-element. The main advantage of this kind of implementation is that you don't
 228     have to create a toXML method for every different graph object. Every element
 229     consists of a type, attribute, optional subelements, optional text and an optional
 230     namespace. Note the elements==None, if elements = None:self.elements=[] construction.
 231     This is done because if you default to elements=[] every object has a reference
 232     to the same empty list."""
 233     def __init__(self,type='',attributes=None,elements=None,text='',namespace='',cdata=None,**args):
 234         self.type=type
 235         if attributes==None:
 236             self.attributes={}
 237         else:
 238             self.attributes=attributes
 239         if elements==None:
 240             self.elements=[]
 241         else:
 242             self.elements=elements
 243         self.text=text
 244         self.namespace=namespace
 245         self.cdata=cdata
 246         for arg in args.keys():
 247             self.attributes[arg]=args[arg]
 248     def addElement(self,SVGelement):
 249         """adds an element to a SVGelement
 250
 251         SVGelement.addElement(SVGelement)
 252         """
 253         self.elements.append(SVGelement)
 254
 255     def toXml(self,level,f):
 256         f.write('\t'*level)
 257         f.write('<'+self.type)
 258         for attkey in self.attributes.keys():
 259             f.write(' '+_escape(str(attkey))+'='+_quoteattr(str(self.attributes[attkey])))
 260         if self.namespace:
 261             f.write(' xmlns="'+ _escape(str(self.namespace))+'" ')
 262         if self.elements or self.text or self.cdata:
 263             f.write('>')
 264         if self.elements:
 265             f.write('\n')
 266         for element in self.elements:
 267             element.toXml(level+1,f)
 268         if self.cdata:
 269             f.write('\n'+'\t'*(level+1)+'<![CDATA[')
 270             for line in self.cdata.splitlines():
 271                f.write('\n'+'\t'*(level+2)+line)
 272             f.write('\n'+'\t'*(level+1)+']]>\n')
 273         if self.text:
 274             if type(self.text)==type(''): #If the text is only text
 275                 f.write(_escape(str(self.text)))
 276             else:                         #If the text is a spannedtext class
 277                 f.write(str(self.text))
 278         if self.elements:
 279             f.write('\t'*level+'</'+self.type+'>\n')
 280         elif self.text:
 281             f.write('</'+self.type+'>\n')
 282         elif self.cdata:
 283             f.write('\t'*level+'</'+self.type+'>\n')
 284         else:
 285             f.write('/>\n')
 286
 287 class tspan(SVGelement):
 288     """ts=tspan(text='',**args)
 289
 290     a tspan element can be used for applying formatting to a textsection
 291     usage:
 292     ts=tspan('this text is bold')
 293     ts.attributes['font-weight']='bold'
 294     st=spannedtext()
 295     st.addtspan(ts)
 296     t=text(3,5,st)
 297     """
 298     def __init__(self,text=None,**args):
 299         SVGelement.__init__(self,'tspan',**args)
 300         if self.text<>None:
 301             self.text=text
 302     def __repr__(self):
 303         s="<tspan"
 304         for key,value in self.attributes.items():
 305          s+= ' %s="%s"' % (key,value)
 306         s+='>'
 307         s+=self.text
 308         s+='</tspan>'
 309         return s
 310
 311 class tref(SVGelement):
 312     """tr=tref(link='',**args)
 313
 314     a tref element can be used for referencing text by a link to its id.
 315     usage:
 316     tr=tref('#linktotext')
 317     st=spannedtext()
 318     st.addtref(tr)
 319     t=text(3,5,st)
 320     """
 321     def __init__(self,link,**args):
 322         SVGelement.__init__(self,'tref',{'xlink:href':link},**args)
 323     def __repr__(self):
 324         s="<tref"
 325
 326         for key,value in self.attributes.items():
 327          s+= ' %s="%s"' % (key,value)
 328         s+='/>'
 329         return s
 330
 331 class spannedtext:
 332     """st=spannedtext(textlist=[])
 333
 334     a spannedtext can be used for text which consists of text, tspan's and tref's
 335     You can use it to add to a text element or path element. Don't add it directly
 336     to a svg or a group element.
 337     usage:
 338
 339     ts=tspan('this text is bold')
 340     ts.attributes['font-weight']='bold'
 341     tr=tref('#linktotext')
 342     tr.attributes['fill']='red'
 343     st=spannedtext()
 344     st.addtspan(ts)
 345     st.addtref(tr)
 346     st.addtext('This text is not bold')
 347     t=text(3,5,st)
 348     """
 349     def __init__(self,textlist=None):
 350         if textlist==None:
 351             self.textlist=[]
 352         else:
 353             self.textlist=textlist
 354     def addtext(self,text=''):
 355         self.textlist.append(text)
 356     def addtspan(self,tspan):
 357         self.textlist.append(tspan)
 358     def addtref(self,tref):
 359         self.textlist.append(tref)
 360     def __repr__(self):
 361         s=""
 362         for element in self.textlist:
 363             s+=str(element)
 364         return s
 365
 366 class rect(SVGelement):
 367     """r=rect(width,height,x,y,fill,stroke,stroke_width,**args)
 368
 369     a rectangle is defined by a width and height and a xy pair
 370     """
 371     def __init__(self,x=None,y=None,width=None,height=None,fill=None,stroke=None,stroke_width=None,**args):
 372         if width==None or height==None:
 373             if width<>None:
 374                 raise ValueError, 'height is required'
 375             if height<>None:
 376                 raise ValueError, 'width is required'
 377             else:
 378                 raise ValueError, 'both height and width are required'
 379         SVGelement.__init__(self,'rect',{'width':width,'height':height},**args)
 380         if x<>None:
 381             self.attributes['x']=x
 382         if y<>None:
 383             self.attributes['y']=y
 384         if fill<>None:
 385             self.attributes['fill']=fill
 386         if stroke<>None:
 387             self.attributes['stroke']=stroke
 388         if stroke_width<>None:
 389             self.attributes['stroke-width']=stroke_width
 390
 391 class ellipse(SVGelement):
 392     """e=ellipse(rx,ry,x,y,fill,stroke,stroke_width,**args)
 393
 394     an ellipse is defined as a center and a x and y radius.
 395     """
 396     def __init__(self,cx=None,cy=None,rx=None,ry=None,fill=None,stroke=None,stroke_width=None,**args):
 397         if rx==None or ry== None:
 398             if rx<>None:
 399                 raise ValueError, 'rx is required'
 400             if ry<>None:
 401                 raise ValueError, 'ry is required'
 402             else:
 403                 raise ValueError, 'both rx and ry are required'
 404         SVGelement.__init__(self,'ellipse',{'rx':rx,'ry':ry},**args)
 405         if cx<>None:
 406             self.attributes['cx']=cx
 407         if cy<>None:
 408             self.attributes['cy']=cy
 409         if fill<>None:
 410             self.attributes['fill']=fill
 411         if stroke<>None:
 412             self.attributes['stroke']=stroke
 413         if stroke_width<>None:
 414             self.attributes['stroke-width']=stroke_width
 415
 416
 417 class circle(SVGelement):
 418     """c=circle(x,y,radius,fill,stroke,stroke_width,**args)
 419
 420     The circle creates an element using a x, y and radius values eg
 421     """
 422     def __init__(self,cx=None,cy=None,r=None,fill=None,stroke=None,stroke_width=None,**args):
 423         if r==None:
 424             raise ValueError, 'r is required'
 425         SVGelement.__init__(self,'circle',{'r':r},**args)
 426         if cx<>None:
 427             self.attributes['cx']=cx
 428         if cy<>None:
 429             self.attributes['cy']=cy
 430         if fill<>None:
 431             self.attributes['fill']=fill
 432         if stroke<>None:
 433             self.attributes['stroke']=stroke
 434         if stroke_width<>None:
 435             self.attributes['stroke-width']=stroke_width
 436
 437 class point(circle):
 438     """p=point(x,y,color)
 439
 440     A point is defined as a circle with a size 1 radius. It may be more efficient to use a
 441     very small rectangle if you use many points because a circle is difficult to render.
 442     """
 443     def __init__(self,x,y,fill='black',**args):
 444         circle.__init__(self,x,y,1,fill,**args)
 445
 446 class line(SVGelement):
 447     """l=line(x1,y1,x2,y2,stroke,stroke_width,**args)
 448
 449     A line is defined by a begin x,y pair and an end x,y pair
 450     """
 451     def __init__(self,x1=None,y1=None,x2=None,y2=None,stroke=None,stroke_width=None,**args):
 452         SVGelement.__init__(self,'line',**args)
 453         if x1<>None:
 454             self.attributes['x1']=x1
 455         if y1<>None:
 456             self.attributes['y1']=y1
 457         if x2<>None:
 458             self.attributes['x2']=x2
 459         if y2<>None:
 460             self.attributes['y2']=y2
 461         if stroke_width<>None:
 462             self.attributes['stroke-width']=stroke_width
 463         if stroke<>None:
 464             self.attributes['stroke']=stroke
 465
 466 class polyline(SVGelement):
 467     """pl=polyline([[x1,y1],[x2,y2],...],fill,stroke,stroke_width,**args)
 468
 469     a polyline is defined by a list of xy pairs
 470     """
 471     def __init__(self,points,fill=None,stroke=None,stroke_width=None,**args):
 472         SVGelement.__init__(self,'polyline',{'points':_xypointlist(points)},**args)
 473         if fill<>None:
 474             self.attributes['fill']=fill
 475         if stroke_width<>None:
 476             self.attributes['stroke-width']=stroke_width
 477         if stroke<>None:
 478             self.attributes['stroke']=stroke
 479
 480 class polygon(SVGelement):
 481     """pl=polyline([[x1,y1],[x2,y2],...],fill,stroke,stroke_width,**args)
 482
 483     a polygon is defined by a list of xy pairs
 484     """
 485     def __init__(self,points,fill=None,stroke=None,stroke_width=None,**args):
 486         SVGelement.__init__(self,'polygon',{'points':_xypointlist(points)},**args)
 487         if fill<>None:
 488             self.attributes['fill']=fill
 489         if stroke_width<>None:
 490             self.attributes['stroke-width']=stroke_width
 491         if stroke<>None:
 492             self.attributes['stroke']=stroke
 493
 494 class path(SVGelement):
 495     """p=path(path,fill,stroke,stroke_width,**args)
 496
 497     a path is defined by a path object and optional width, stroke and fillcolor
 498     """
 499     def __init__(self,pathdata,fill=None,stroke=None,stroke_width=None,id=None,**args):
 500         SVGelement.__init__(self,'path',{'d':str(pathdata)},**args)
 501         if stroke<>None:
 502             self.attributes['stroke']=stroke
 503         if fill<>None:
 504             self.attributes['fill']=fill
 505         if stroke_width<>None:
 506             self.attributes['stroke-width']=stroke_width
 507         if id<>None:
 508             self.attributes['id']=id
 509
 510
 511 class text(SVGelement):
 512     """t=text(x,y,text,font_size,font_family,**args)
 513
 514     a text element can bge used for displaying text on the screen
 515     """
 516     def __init__(self,x=None,y=None,text=None,font_size=None,font_family=None,text_anchor=None,**args):
 517         SVGelement.__init__(self,'text',**args)
 518         if x<>None:
 519             self.attributes['x']=x
 520         if y<>None:
 521             self.attributes['y']=y
 522         if font_size<>None:
 523             self.attributes['font-size']=font_size
 524         if font_family<>None:
 525             self.attributes['font-family']=font_family
 526         if text<>None:
 527             self.text=text
 528         if text_anchor<>None:
 529             self.attributes['text-anchor']=text_anchor
 530
 531
 532 class textpath(SVGelement):
 533     """tp=textpath(text,link,**args)
 534
 535     a textpath places a text on a path which is referenced by a link.
 536     """
 537     def __init__(self,link,text=None,**args):
 538         SVGelement.__init__(self,'textPath',{'xlink:href':link},**args)
 539         if text<>None:
 540             self.text=text
 541
 542 class pattern(SVGelement):
 543     """p=pattern(x,y,width,height,patternUnits,**args)
 544
 545     A pattern is used to fill or stroke an object using a pre-defined
 546     graphic object which can be replicated ("tiled") at fixed intervals
 547     in x and y to cover the areas to be painted.
 548     """
 549     def __init__(self,x=None,y=None,width=None,height=None,patternUnits=None,**args):
 550         SVGelement.__init__(self,'pattern',**args)
 551         if x<>None:
 552             self.attributes['x']=x
 553         if y<>None:
 554             self.attributes['y']=y
 555         if width<>None:
 556             self.attributes['width']=width
 557         if height<>None:
 558             self.attributes['height']=height
 559         if patternUnits<>None:
 560             self.attributes['patternUnits']=patternUnits
 561
 562 class title(SVGelement):
 563     """t=title(text,**args)
 564
 565     a title is a text element. The text is displayed in the title bar
 566     add at least one to the root svg element
 567     """
 568     def __init__(self,text=None,**args):
 569         SVGelement.__init__(self,'title',**args)
 570         if text<>None:
 571             self.text=text
 572
 573 class description(SVGelement):
 574     """d=description(text,**args)
 575
 576     a description can be added to any element and is used for a tooltip
 577     Add this element before adding other elements.
 578     """
 579     def __init__(self,text=None,**args):
 580         SVGelement.__init__(self,'desc',**args)
 581         if text<>None:
 582             self.text=text
 583
 584 class lineargradient(SVGelement):
 585     """lg=lineargradient(x1,y1,x2,y2,id,**args)
 586
 587     defines a lineargradient using two xy pairs.
 588     stop elements van be added to define the gradient colors.
 589     """
 590     def __init__(self,x1=None,y1=None,x2=None,y2=None,id=None,**args):
 591         SVGelement.__init__(self,'linearGradient',**args)
 592         if x1<>None:
 593             self.attributes['x1']=x1
 594         if y1<>None:
 595             self.attributes['y1']=y1
 596         if x2<>None:
 597             self.attributes['x2']=x2
 598         if y2<>None:
 599             self.attributes['y2']=y2
 600         if id<>None:
 601             self.attributes['id']=id
 602
 603 class radialgradient(SVGelement):
 604     """rg=radialgradient(cx,cy,r,fx,fy,id,**args)
 605
 606     defines a radial gradient using a outer circle which are defined by a cx,cy and r and by using a focalpoint.
 607     stop elements van be added to define the gradient colors.
 608     """
 609     def __init__(self,cx=None,cy=None,r=None,fx=None,fy=None,id=None,**args):
 610         SVGelement.__init__(self,'radialGradient',**args)
 611         if cx<>None:
 612             self.attributes['cx']=cx
 613         if cy<>None:
 614             self.attributes['cy']=cy
 615         if r<>None:
 616             self.attributes['r']=r
 617         if fx<>None:
 618             self.attributes['fx']=fx
 619         if fy<>None:
 620             self.attributes['fy']=fy
 621         if id<>None:
 622             self.attributes['id']=id
 623
 624 class stop(SVGelement):
 625     """st=stop(offset,stop_color,**args)
 626
 627     Puts a stop color at the specified radius
 628     """
 629     def __init__(self,offset,stop_color=None,**args):
 630         SVGelement.__init__(self,'stop',{'offset':offset},**args)
 631         if stop_color<>None:
 632             self.attributes['stop-color']=stop_color
 633
 634 class style(SVGelement):
 635     """st=style(type,cdata=None,**args)
 636
 637     Add a CDATA element to this element for defing in line stylesheets etc..
 638     """
 639     def __init__(self,type,cdata=None,**args):
 640         SVGelement.__init__(self,'style',{'type':type},cdata=cdata, **args)
 641
 642
 643 class image(SVGelement):
 644     """im=image(url,width,height,x,y,**args)
 645
 646     adds an image to the drawing. Supported formats are .png, .jpg and .svg.
 647     """
 648     def __init__(self,url,x=None,y=None,width=None,height=None,**args):
 649         if width==None or height==None:
 650             if width<>None:
 651                 raise ValueError, 'height is required'
 652             if height<>None:
 653                 raise ValueError, 'width is required'
 654             else:
 655                 raise ValueError, 'both height and width are required'
 656         SVGelement.__init__(self,'image',{'xlink:href':url,'width':width,'height':height},**args)
 657         if x<>None:
 658             self.attributes['x']=x
 659         if y<>None:
 660             self.attributes['y']=y
 661
 662 class cursor(SVGelement):
 663     """c=cursor(url,**args)
 664
 665     defines a custom cursor for a element or a drawing
 666     """
 667     def __init__(self,url,**args):
 668         SVGelement.__init__(self,'cursor',{'xlink:href':url},**args)
 669
 670
 671 class marker(SVGelement):
 672     """m=marker(id,viewbox,refX,refY,markerWidth,markerHeight,**args)
 673
 674     defines a marker which can be used as an endpoint for a line or other pathtypes
 675     add an element to it which should be used as a marker.
 676     """
 677     def __init__(self,id=None,viewBox=None,refx=None,refy=None,markerWidth=None,markerHeight=None,**args):
 678         SVGelement.__init__(self,'marker',**args)
 679         if id<>None:
 680             self.attributes['id']=id
 681         if viewBox<>None:
 682             self.attributes['viewBox']=_viewboxlist(viewBox)
 683         if refx<>None:
 684             self.attributes['refX']=refx
 685         if refy<>None:
 686             self.attributes['refY']=refy
 687         if markerWidth<>None:
 688             self.attributes['markerWidth']=markerWidth
 689         if markerHeight<>None:
 690             self.attributes['markerHeight']=markerHeight
 691
 692 class group(SVGelement):
 693     """g=group(id,**args)
 694
 695     a group is defined by an id and is used to contain elements
 696     g.addElement(SVGelement)
 697     """
 698     def __init__(self,id=None,**args):
 699         SVGelement.__init__(self,'g',**args)
 700         if id<>None:
 701             self.attributes['id']=id
 702
 703 class symbol(SVGelement):
 704     """sy=symbol(id,viewbox,**args)
 705
 706     defines a symbol which can be used on different places in your graph using
 707     the use element. A symbol is not rendered but you can use 'use' elements to
 708     display it by referencing its id.
 709     sy.addElement(SVGelement)
 710     """
 711
 712     def __init__(self,id=None,viewBox=None,**args):
 713         SVGelement.__init__(self,'symbol',**args)
 714         if id<>None:
 715             self.attributes['id']=id
 716         if viewBox<>None:
 717             self.attributes['viewBox']=_viewboxlist(viewBox)
 718
 719 class defs(SVGelement):
 720     """d=defs(**args)
 721
 722     container for defining elements
 723     """
 724     def __init__(self,**args):
 725         SVGelement.__init__(self,'defs',**args)
 726
 727 class switch(SVGelement):
 728     """sw=switch(**args)
 729
 730     Elements added to a switch element which are "switched" by the attributes
 731     requiredFeatures, requiredExtensions and systemLanguage.
 732     Refer to the SVG specification for details.
 733     """
 734     def __init__(self,**args):
 735         SVGelement.__init__(self,'switch',**args)
 736
 737
 738 class use(SVGelement):
 739     """u=use(link,x,y,width,height,**args)
 740
 741     references a symbol by linking to its id and its position, height and width
 742     """
 743     def __init__(self,link,x=None,y=None,width=None,height=None,**args):
 744         SVGelement.__init__(self,'use',{'xlink:href':link},**args)
 745         if x<>None:
 746             self.attributes['x']=x
 747         if y<>None:
 748             self.attributes['y']=y
 749
 750         if width<>None:
 751             self.attributes['width']=width
 752         if height<>None:
 753             self.attributes['height']=height
 754
 755
 756 class link(SVGelement):
 757     """a=link(url,**args)
 758
 759     a link  is defined by a hyperlink. add elements which have to be linked
 760     a.addElement(SVGelement)
 761     """
 762     def __init__(self,link='',**args):
 763         SVGelement.__init__(self,'a',{'xlink:href':link},**args)
 764
 765 class view(SVGelement):
 766     """v=view(id,**args)
 767
 768     a view can be used to create a view with different attributes"""
 769     def __init__(self,id=None,**args):
 770         SVGelement.__init__(self,'view',**args)
 771         if id<>None:
 772             self.attributes['id']=id
 773
 774 class script(SVGelement):
 775     """sc=script(type,type,cdata,**args)
 776
 777     adds a script element which contains CDATA to the SVG drawing
 778
 779     """
 780     def __init__(self,type,cdata=None,**args):
 781         SVGelement.__init__(self,'script',{'type':type},cdata=cdata,**args)
 782
 783 class animate(SVGelement):
 784     """an=animate(attribute,from,to,during,**args)
 785
 786     animates an attribute.
 787     """
 788     def __init__(self,attribute,fr=None,to=None,dur=None,**args):
 789         SVGelement.__init__(self,'animate',{'attributeName':attribute},**args)
 790         if fr<>None:
 791             self.attributes['from']=fr
 792         if to<>None:
 793             self.attributes['to']=to
 794         if dur<>None:
 795             self.attributes['dur']=dur
 796
 797 class animateMotion(SVGelement):
 798     """an=animateMotion(pathdata,dur,**args)
 799
 800     animates a SVGelement over the given path in dur seconds
 801     """
 802     def __init__(self,pathdata,dur,**args):
 803         SVGelement.__init__(self,'animateMotion',**args)
 804         if pathdata<>None:
 805             self.attributes['path']=str(pathdata)
 806         if dur<>None:
 807             self.attributes['dur']=dur
 808
 809 class animateTransform(SVGelement):
 810     """antr=animateTransform(type,from,to,dur,**args)
 811
 812     transform an element from and to a value.
 813     """
 814     def __init__(self,type=None,fr=None,to=None,dur=None,**args):
 815         SVGelement.__init__(self,'animateTransform',{'attributeName':'transform'},**args)
 816         #As far as I know the attributeName is always transform
 817         if type<>None:
 818             self.attributes['type']=type
 819         if fr<>None:
 820             self.attributes['from']=fr
 821         if to<>None:
 822             self.attributes['to']=to
 823         if dur<>None:
 824             self.attributes['dur']=dur
 825 class animateColor(SVGelement):
 826     """ac=animateColor(attribute,type,from,to,dur,**args)
 827
 828     Animates the color of a element
 829     """
 830     def __init__(self,attribute,type=None,fr=None,to=None,dur=None,**args):
 831         SVGelement.__init__(self,'animateColor',{'attributeName':attribute},**args)
 832         if type<>None:
 833             self.attributes['type']=type
 834         if fr<>None:
 835             self.attributes['from']=fr
 836         if to<>None:
 837             self.attributes['to']=to
 838         if dur<>None:
 839             self.attributes['dur']=dur
 840 class set(SVGelement):
 841     """st=set(attribute,to,during,**args)
 842
 843     sets an attribute to a value for a
 844     """
 845     def __init__(self,attribute,to=None,dur=None,**args):
 846         SVGelement.__init__(self,'set',{'attributeName':attribute},**args)
 847         if to<>None:
 848             self.attributes['to']=to
 849         if dur<>None:
 850             self.attributes['dur']=dur
 851
 852
 853
 854 class svg(SVGelement):
 855     """s=svg(viewbox,width,height,**args)
 856
 857     a svg or element is the root of a drawing add all elements to a svg element.
 858     You can have different svg elements in one svg file
 859     s.addElement(SVGelement)
 860
 861     eg
 862     d=drawing()
 863     s=svg((0,0,100,100),'100%','100%')
 864     c=circle(50,50,20)
 865     s.addElement(c)
 866     d.setSVG(s)
 867     d.toXml()
 868     """
 869     def __init__(self,viewBox=None, width=None, height=None,**args):
 870         SVGelement.__init__(self,'svg',**args)
 871         if viewBox<>None:
 872             self.attributes['viewBox']=_viewboxlist(viewBox)
 873         if width<>None:
 874             self.attributes['width']=width
 875         if height<>None:
 876             self.attributes['height']=height
 877         self.namespace="http://www.w3.org/2000/svg"
 878
 879 class drawing:
 880     """d=drawing()
 881
 882     this is the actual SVG document. It needs a svg element as a root.
 883     Use the addSVG method to set the svg to the root. Use the toXml method to write the SVG
 884     source to the screen or to a file
 885     d=drawing()
 886     d.addSVG(svg)
 887     d.toXml(optionalfilename)
 888     """
 889
 890     def __init__(self):
 891         self.svg=None
 892     def setSVG(self,svg):
 893         self.svg=svg
 894         #Voeg een element toe aan de grafiek toe.
 895     if use_dom_implementation==0:
 896         def toXml(self, filename='',compress=False):
 897             import cStringIO
 898             xml=cStringIO.StringIO()
 899             xml.write("<?xml version='1.0' encoding='UTF-8'?>\n")
 900             xml.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd \">\n")
 901             self.svg.toXml(0,xml)
 902             if not filename:
 903                 if compress:
 904                     import gzip
 905                     f=cStringIO.StringIO()
 906                     zf=gzip.GzipFile(fileobj=f,mode='wb')
 907                     zf.write(xml.getvalue())
 908                     zf.close()
 909                     f.seek(0)
 910                     return f.read()
 911                 else:
 912                     return xml.getvalue()
 913             else:
 914                 if filename[-4:]=='svgz':
 915                     import gzip
 916                     f=gzip.GzipFile(filename=filename,mode="wb", compresslevel=9)
 917                     f.write(xml.getvalue())
 918                     f.close()
 919                 else:
 920                     f=file(filename,'w')
 921                     f.write(xml.getvalue())
 922                     f.close()
 923
 924     else:
 925         def toXml(self,filename='',compress=False):
 926             """drawing.toXml()        ---->to the screen
 927             drawing.toXml(filename)---->to the file
 928             writes a svg drawing to the screen or to a file
 929             compresses if filename ends with svgz or if compress is true
 930             """
 931             doctype = implementation.createDocumentType('svg',"-//W3C//DTD SVG 1.0//EN""",'http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd ')
 932
 933             global root
 934             #root is defined global so it can be used by the appender. Its also possible to use it as an arugument but
 935             #that is a bit messy.
 936             root=implementation.createDocument(None,None,doctype)
 937             #Create the xml document.
 938             global appender
 939             def appender(element,elementroot):
 940                 """This recursive function appends elements to an element and sets the attributes
 941                 and type. It stops when alle elements have been appended"""
 942                 if element.namespace:
 943                     e=root.createElementNS(element.namespace,element.type)
 944                 else:
 945                     e=root.createElement(element.type)
 946                 if element.text:
 947                     textnode=root.createTextNode(element.text)
 948                     e.appendChild(textnode)
 949                 for attribute in element.attributes.keys():   #in element.attributes is supported from python 2.2
 950                     e.setAttribute(attribute,str(element.attributes[attribute]))
 951                 if element.elements:
 952                     for el in element.elements:
 953                         e=appender(el,e)
 954                 elementroot.appendChild(e)
 955                 return elementroot
 956             root=appender(self.svg,root)
 957             if not filename:
 958                 import cStringIO
 959                 xml=cStringIO.StringIO()
 960                 PrettyPrint(root,xml)
 961                 if compress:
 962                     import gzip
 963                     f=cStringIO.StringIO()
 964                     zf=gzip.GzipFile(fileobj=f,mode='wb')
 965                     zf.write(xml.getvalue())
 966                     zf.close()
 967                     f.seek(0)
 968                     return f.read()
 969                 else:
 970                     return xml.getvalue()
 971             else:
 972                 try:
 973                     if filename[-4:]=='svgz':
 974                         import gzip
 975                         import cStringIO
 976                         xml=cStringIO.StringIO()
 977                         PrettyPrint(root,xml)
 978                         f=gzip.GzipFile(filename=filename,mode='wb',compresslevel=9)
 979                         f.write(xml.getvalue())
 980                         f.close()
 981                     else:
 982                         f=open(filename,'w')
 983                         PrettyPrint(root,f)
 984                         f.close()
 985                 except:
 986                     print "Cannot write SVG file: " + filename
 987     def validate(self):
 988         try:
 989             import xml.parsers.xmlproc.xmlval
 990         except:
 991             raise exceptions.ImportError,'PyXml is required for validating SVG'
 992         svg=self.toXml()
 993         xv=xml.parsers.xmlproc.xmlval.XMLValidator()
 994         try:
 995             xv.feed(svg)
 996         except:
 997             raise "SVG is not well formed, see messages above"
 998         else:
 999             print "SVG well formed"
1000 if __name__=='__main__':
1001
1002
1003     d=drawing()
1004     s=svg((0,0,100,100))
1005     r=rect(-100,-100,300,300,'cyan')
1006     s.addElement(r)
1007
1008     t=title('SVGdraw Demo')
1009     s.addElement(t)
1010     g=group('animations')
1011     e=ellipse(0,0,5,2)
1012     g.addElement(e)
1013     c=circle(0,0,1,'red')
1014     g.addElement(c)
1015     pd=pathdata(0,-10)
1016     for i in range(6):
1017         pd.relsmbezier(10,5,0,10)
1018         pd.relsmbezier(-10,5,0,10)
1019     an=animateMotion(pd,10)
1020     an.attributes['rotate']='auto-reverse'
1021     an.attributes['repeatCount']="indefinite"
1022     g.addElement(an)
1023     s.addElement(g)
1024     for i in range(20,120,20):
1025         u=use('#animations',i,0)
1026         s.addElement(u)
1027     for i in range(0,120,20):
1028         for j in range(5,105,10):
1029             c=circle(i,j,1,'red','black',.5)
1030             s.addElement(c)
1031     d.setSVG(s)
1032
1033     print d.toXml()
1034