def guardar_a_svg(self, nombrearchivo = None):
     """
     Dibuja el código de barras en SVG.
     Devuelve el nombre del archivo.
     """
     if not nombrearchivo:
         import time, os
         from tempfile import gettempdir
         nombrearchivo = os.path.join(gettempdir(), "barcode39_%s.svg" % ('_'.join(map(str, time.localtime()[:6]))))
     from reportlab.graphics.shapes import Drawing
     from reportlab.lib.units import cm
     tamcanvas = (self.width + 2, self.height + 10 + 0.4 * cm)
     dw = Drawing(width = tamcanvas[0], height = tamcanvas[1])
     self.drawOnDW(dw, 1, tamcanvas[1] - 5 - self.height)
     from reportlab.graphics import renderSVG
     renderSVG.drawToFile(dw, nombrearchivo, "SVG")
     nombrearchivo = self.__corregir_stroke_linecap(nombrearchivo)
     return nombrearchivo

    def test0(self):
        "Test two strings in drawing."

        path = outputfile("test_renderSVG_simple_test0.svg")

        d = Drawing(200, 100)
        d.add(String(0, 0, "foo"))
        d.add(String(100, 0, "bar"))
        renderSVG.drawToFile(d, path)

        if not HAVE_XML_PARSER:
            warnIgnoredRestofTest()
            return

        svg = load(path)
        fg = svg.getElementsByTagName('g')[0]           # flipping group
        dg = fg.getElementsByTagName('g')[0]            # diagram group
        textChildren = dg.getElementsByTagName('text')  # text nodes
        t0 = (textChildren[0].childNodes[0].nodeValue).strip()
        t1 = (textChildren[1].childNodes[0].nodeValue).strip()
        assert t0 == 'foo'
        assert t1 == 'bar'

def render_svg(drawing, opts, outbuf=None):
    if opts.pagesize in name2size:
        pagesize = name2size[opts.pagesize]
    else:
        pagesize = opts.pagesize or letter
    border = opts.border or 1*cm
    landscape = opts.landscape or False
    pgwidth, pgheight = pagesize if not landscape \
                        else (pagesize[1], pagesize[0])
    #print "drawing width, height:", drawing.width/inch, drawing.height/inch
    if drawing.width > pgwidth - 2*border:
        scalefact = (pgwidth - 2*border)/float(drawing.width)
        drawing.scale(scalefact, scalefact)
    else:
        scalefact = 1.0
    #border *= scalefact
    dwidth = drawing.width*scalefact
    dheight = drawing.height*scalefact

    buf = StringIO()
    renderSVG.drawToFile(drawing, buf)
    return buf.getvalue()

    def test2(self):
        "Generate PDF and SVG documents of third sample drawing."

        d = self.makeDrawing2()
        renderPDF.drawToFile(d, outputfile('test_widgets_grids2.pdf'))
        renderSVG.drawToFile(d, outputfile('test_widgets_grids2.svg'))

    def test1(self):
        "Generate PDF and SVG documents of second sample drawing."

        d = self.makeDrawing1()
        renderPDF.drawToFile(d, outputfile('test_widgets_grids1.pdf'))
        renderSVG.drawToFile(d, outputfile('test_widgets_grids1.svg'))

    def test0(self):
        "Generate PDF and SVG documents of first sample drawing."

        d = self.makeDrawing0()
        renderPDF.drawToFile(d, outputfile('test_widgets_grids0.pdf'))
        renderSVG.drawToFile(d, outputfile('test_widgets_grids0.svg'))

  def generate(self, value, stream=None,
               format='eps', includeText=None, textSize=14, dpi=300,
	       lineWidth = 1.2, lineHeight = 36):
    """
    Generates the requested bar code either via a stream or as the
    requested object type.

    @param value:   The string to convert to a barcode
    @param stream:  Optional argument of file name as a string, or any
                    open file style object.
    @param format: The format in which the output should be generated.
                  Valid file formats include pdf, eps, svg and
                  will require the stream argument be provided.
                  Valid object formats include
                  rldrawing (ReportLab Drawing object will be returned,
                  No stream argument is required).
    @param includeText: Boolean.  If true then human readable text will
                        be printed centered under the barcode.
    @param textSize: The point size of the human readable text.
    @param dpi: The dots per inch at which the bitmap should be generated.

    @return: None or a format dependent object.  Valid return values::
            eps : None
            pdf : None
            svg : None
            rl  : ReportLab Drawing
    @rtype: misc
    """

    assert (format in ('rl','pil') or stream is not None)

    d = self._generateDrawing(value, includeText, textSize, dpi)

    #
    # Process formats that return value instead of write to a file
    #
    if format == 'rl':
      return d

    #
    # A stream is required for the remaining formats
    #
    if not hasattr(stream, 'write'):
      closeFile = True
      stream = open(stream,'w')
    else:
      closeFile = False

    if format == 'pdf':
      from reportlab.graphics import renderPDF
      renderPDF.drawToFile(d, stream, 'GNUe')
    elif format == 'eps':
      from reportlab.graphics import renderPS
      renderPS.drawToFile(d, stream)
    elif format == 'svg':
      from reportlab.graphics import renderSVG
      renderSVG.drawToFile(d, stream)
##    elif format in ('png','tiff'):
##      from reportlab.graphics import renderPM
##      renderPM.drawToFile(d, stream,format.upper(), dpi=dpi)
##    elif format in ('pil',):
##      from reportlab.graphics import renderPM
##      return renderPM.drawToPIL(d, dpi=dpi)


#
# This code *should* be replaced with calls to renderPM
# but that appears broken in the .debs
#
    ##
    ## Raster-based output using PIL
    ##
    elif format in ('png','tiff','ppm','xbm'):

      code = value 	##
    
      lineWidth = int(lineWidth * dpi/72+.5)   # 300dpi
      lineHeight = int(lineHeight * dpi/72+.5)  # 300dpi
      # Special case for PostNet
      lineHeight2 = int(lineHeight * .45+.5)

      # Create a new monochrome image with a white backgint
      image = Image.new('1',(int(len(code)*lineWidth+.5),
         int(lineHeight+.5)), 1)
      draw = ImageDraw.Draw(image)
      offs = 0
      for ch in code:
        if ch == '1':
          draw.rectangle((offs,0,offs+lineWidth-1,lineHeight),
                          outline=0, fill=0)
        # Special case for PostNet
        elif ch == '2':
          draw.rectangle((offs,0,offs+lineWidth-1,lineHeight2),
                          outline=0, fill=0)
        offs += lineWidth

      image.save(stream, format)

    if closeFile:
      stream.close()

def drawToFile(bc, filename):
    """Write barcode to SVG file <filename>."""
    renderSVG.drawToFile(barcode.rl.draw_barcode(bc), filename)