Removed reportlab

bzr revid: pinky-6fa6b5bb1cfc5dd54307cd22a31f527d28d61e05

1 files changed, 0 insertions, 841 deletions

diff --git a/bin/reportlab/tools/pythonpoint/demos/examples.py b/bin/reportlab/tools/pythonpoint/demos/examples.py
deleted file mode 100644
index 14aee2336fb..00000000000
--- a/bin/reportlab/tools/pythonpoint/demos/examples.py
+++ /dev/null
@@ -1,841 +0,0 @@
-import string
-
-testannotations="""
-def annotations(canvas):
-    from reportlab.lib.units import inch
-    canvas.drawString(inch, 2.5*inch,
-       "setAuthor, setTitle, setSubject have no visible effect")
-    canvas.drawString(inch, inch, "But if you are viewing this document dynamically")
-    canvas.drawString(inch, 0.5*inch, "please look at File/Document Info")
-    canvas.setAuthor("the ReportLab Team")
-    canvas.setTitle("ReportLab PDF Generation User Guide")
-    canvas.setSubject("How to Generate PDF files using the ReportLab modules")
-"""
-
-# magic function making module
-
-test1 = """
-def f(a,b):
-    print "it worked", a, b
-    return a+b
-"""
-
-test2 = """
-def g(n):
-    if n==0: return 1
-    else: return n*g(n-1)
-    """
-
-testhello = """
-def hello(c):
-    from reportlab.lib.units import inch
-    # move the origin up and to the left
-    c.translate(inch,inch)
-    # define a large font
-    c.setFont("Helvetica", 14)
-    # choose some colors
-    c.setStrokeColorRGB(0.2,0.5,0.3)
-    c.setFillColorRGB(1,0,1)
-    # draw some lines
-    c.line(0,0,0,1.7*inch)
-    c.line(0,0,1*inch,0)
-    # draw a rectangle
-    c.rect(0.2*inch,0.2*inch,1*inch,1.5*inch, fill=1)
-    # make text go straight up
-    c.rotate(90)
-    # change color
-    c.setFillColorRGB(0,0,0.77)
-    # say hello (note after rotate the y coord needs to be negative!)
-    c.drawString(0.3*inch, -inch, "Hello World")
-"""
-
-testcoords = """
-def coords(canvas):
-    from reportlab.lib.units import inch
-    from reportlab.lib.colors import pink, black, red, blue, green
-    c = canvas
-    c.setStrokeColor(pink)
-    c.grid([inch, 2*inch, 3*inch, 4*inch], [0.5*inch, inch, 1.5*inch, 2*inch, 2.5*inch])
-    c.setStrokeColor(black)
-    c.setFont("Times-Roman", 20)
-    c.drawString(0,0, "(0,0) the Origin")
-    c.drawString(2.5*inch, inch, "(2.5,1) in inches")
-    c.drawString(4*inch, 2.5*inch, "(4, 2.5)")
-    c.setFillColor(red)
-    c.rect(0,2*inch,0.2*inch,0.3*inch, fill=1)
-    c.setFillColor(green)
-    c.circle(4.5*inch, 0.4*inch, 0.2*inch, fill=1)
-"""
-
-testtranslate = """
-def translate(canvas):
-    from reportlab.lib.units import cm
-    canvas.translate(2.3*cm, 0.3*cm)
-    coords(canvas)
-    """
-
-testscale = """
-def scale(canvas):
-    canvas.scale(0.75, 0.5)
-    coords(canvas)
-"""
-
-testscaletranslate = """
-def scaletranslate(canvas):
-    from reportlab.lib.units import inch
-    canvas.setFont("Courier-BoldOblique", 12)
-    # save the state
-    canvas.saveState()
-    # scale then translate
-    canvas.scale(0.3, 0.5)
-    canvas.translate(2.4*inch, 1.5*inch)
-    canvas.drawString(0, 2.7*inch, "Scale then translate")
-    coords(canvas)
-    # forget the scale and translate...
-    canvas.restoreState()
-    # translate then scale
-    canvas.translate(2.4*inch, 1.5*inch)
-    canvas.scale(0.3, 0.5)
-    canvas.drawString(0, 2.7*inch, "Translate then scale")
-    coords(canvas)
-"""
-
-testmirror = """
-def mirror(canvas):
-    from reportlab.lib.units import inch
-    canvas.translate(5.5*inch, 0)
-    canvas.scale(-1.0, 1.0)
-    coords(canvas)
-"""
-
-testcolors = """
-def colors(canvas):
-    from reportlab.lib import colors
-    from reportlab.lib.units import inch
-    black = colors.black
-    y = x = 0; dy=inch*3/4.0; dx=inch*5.5/5; w=h=dy/2; rdx=(dx-w)/2
-    rdy=h/5.0; texty=h+2*rdy
-    canvas.setFont("Helvetica",10)
-    for [namedcolor, name] in (
-           [colors.lavenderblush, "lavenderblush"],
-           [colors.lawngreen, "lawngreen"],
-           [colors.lemonchiffon, "lemonchiffon"],
-           [colors.lightblue, "lightblue"],
-           [colors.lightcoral, "lightcoral"]):
-        canvas.setFillColor(namedcolor)
-        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
-        canvas.setFillColor(black)
-        canvas.drawCentredString(x+dx/2, y+texty, name)
-        x = x+dx
-    y = y + dy; x = 0
-    for rgb in [(1,0,0), (0,1,0), (0,0,1), (0.5,0.3,0.1), (0.4,0.5,0.3)]:
-        r,g,b = rgb
-        canvas.setFillColorRGB(r,g,b)
-        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
-        canvas.setFillColor(black)
-        canvas.drawCentredString(x+dx/2, y+texty, "r%s g%s b%s"%rgb)
-        x = x+dx
-    y = y + dy; x = 0
-    for cmyk in [(1,0,0,0), (0,1,0,0), (0,0,1,0), (0,0,0,1), (0,0,0,0)]:
-        c,m,y1,k = cmyk
-        canvas.setFillColorCMYK(c,m,y1,k)
-        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
-        canvas.setFillColor(black)
-        canvas.drawCentredString(x+dx/2, y+texty, "c%s m%s y%s k%s"%cmyk)
-        x = x+dx
-    y = y + dy; x = 0
-    for gray in (0.0, 0.25, 0.50, 0.75, 1.0):
-        canvas.setFillGray(gray)
-        canvas.rect(x+rdx, y+rdy, w, h, fill=1)
-        canvas.setFillColor(black)
-        canvas.drawCentredString(x+dx/2, y+texty, "gray: %s"%gray)
-        x = x+dx
-"""
-
-testspumoni = """
-def spumoni(canvas):
-    from reportlab.lib.units import inch
-    from reportlab.lib.colors import pink, green, brown, white
-    x = 0; dx = 0.4*inch
-    for i in range(4):
-        for color in (pink, green, brown):
-            canvas.setFillColor(color)
-            canvas.rect(x,0,dx,3*inch,stroke=0,fill=1)
-            x = x+dx
-    canvas.setFillColor(white)
-    canvas.setStrokeColor(white)
-    canvas.setFont("Helvetica-Bold", 85)
-    canvas.drawCentredString(2.75*inch, 1.3*inch, "SPUMONI")
-"""
-
-testspumoni2 = """
-def spumoni2(canvas):
-    from reportlab.lib.units import inch
-    from reportlab.lib.colors import pink, green, brown, white, black
-    # draw the previous drawing
-    spumoni(canvas)
-    # now put an ice cream cone on top of it:
-    # first draw a triangle (ice cream cone)
-    p = canvas.beginPath()
-    xcenter = 2.75*inch
-    radius = 0.45*inch
-    p.moveTo(xcenter-radius, 1.5*inch)
-    p.lineTo(xcenter+radius, 1.5*inch)
-    p.lineTo(xcenter, 0)
-    canvas.setFillColor(brown)
-    canvas.setStrokeColor(black)
-    canvas.drawPath(p, fill=1)
-    # draw some circles (scoops)
-    y = 1.5*inch
-    for color in (pink, green, brown):
-        canvas.setFillColor(color)
-        canvas.circle(xcenter, y, radius, fill=1)
-        y = y+radius
-"""
-
-testbezier = """
-def bezier(canvas):
-    from reportlab.lib.colors import yellow, green, red, black
-    from reportlab.lib.units import inch
-    i = inch
-    d = i/4
-    # define the bezier curve control points
-    x1,y1, x2,y2, x3,y3, x4,y4 = d,1.5*i, 1.5*i,d, 3*i,d, 5.5*i-d,3*i-d
-    # draw a figure enclosing the control points
-    canvas.setFillColor(yellow)
-    p = canvas.beginPath()
-    p.moveTo(x1,y1)
-    for (x,y) in [(x2,y2), (x3,y3), (x4,y4)]:
-        p.lineTo(x,y)
-    canvas.drawPath(p, fill=1, stroke=0)
-    # draw the tangent lines
-    canvas.setLineWidth(inch*0.1)
-    canvas.setStrokeColor(green)
-    canvas.line(x1,y1,x2,y2)
-    canvas.setStrokeColor(red)
-    canvas.line(x3,y3,x4,y4)
-    # finally draw the curve
-    canvas.setStrokeColor(black)
-    canvas.bezier(x1,y1, x2,y2, x3,y3, x4,y4)
-"""
-
-testbezier2 = """
-def bezier2(canvas):
-    from reportlab.lib.colors import yellow, green, red, black
-    from reportlab.lib.units import inch
-    # make a sequence of control points
-    xd,yd = 5.5*inch/2, 3*inch/2
-    xc,yc = xd,yd
-    dxdy = [(0,0.33), (0.33,0.33), (0.75,1), (0.875,0.875),
-            (0.875,0.875), (1,0.75), (0.33,0.33), (0.33,0)]
-    pointlist = []
-    for xoffset in (1,-1):
-        yoffset = xoffset
-        for (dx,dy) in dxdy:
-            px = xc + xd*xoffset*dx
-            py = yc + yd*yoffset*dy
-            pointlist.append((px,py))
-        yoffset = -xoffset
-        for (dy,dx) in dxdy:
-            px = xc + xd*xoffset*dx
-            py = yc + yd*yoffset*dy
-            pointlist.append((px,py))
-    # draw tangent lines and curves
-    canvas.setLineWidth(inch*0.1)
-    while pointlist:
-        [(x1,y1),(x2,y2),(x3,y3),(x4,y4)] = pointlist[:4]
-        del pointlist[:4]
-        canvas.setLineWidth(inch*0.1)
-        canvas.setStrokeColor(green)
-        canvas.line(x1,y1,x2,y2)
-        canvas.setStrokeColor(red)
-        canvas.line(x3,y3,x4,y4)
-        # finally draw the curve
-        canvas.setStrokeColor(black)
-        canvas.bezier(x1,y1, x2,y2, x3,y3, x4,y4)
-"""
-
-testpencil = """
-def pencil(canvas, text="No.2"):
-    from reportlab.lib.colors import yellow, red, black,white
-    from reportlab.lib.units import inch
-    u = inch/10.0
-    canvas.setStrokeColor(black)
-    canvas.setLineWidth(4)
-    # draw erasor
-    canvas.setFillColor(red)
-    canvas.circle(30*u, 5*u, 5*u, stroke=1, fill=1)
-    # draw all else but the tip (mainly rectangles with different fills)
-    canvas.setFillColor(yellow)
-    canvas.rect(10*u,0,20*u,10*u, stroke=1, fill=1)
-    canvas.setFillColor(black)
-    canvas.rect(23*u,0,8*u,10*u,fill=1)
-    canvas.roundRect(14*u, 3.5*u, 8*u, 3*u, 1.5*u, stroke=1, fill=1)
-    canvas.setFillColor(white)
-    canvas.rect(25*u,u,1.2*u,8*u, fill=1,stroke=0)
-    canvas.rect(27.5*u,u,1.2*u,8*u, fill=1, stroke=0)
-    canvas.setFont("Times-Roman", 3*u)
-    canvas.drawCentredString(18*u, 4*u, text)
-    # now draw the tip
-    penciltip(canvas,debug=0)
-    # draw broken lines across the body.
-    canvas.setDash([10,5,16,10],0)
-    canvas.line(11*u,2.5*u,22*u,2.5*u)
-    canvas.line(22*u,7.5*u,12*u,7.5*u)
-    """
-
-testpenciltip = """
-def penciltip(canvas, debug=1):
-    from reportlab.lib.colors import tan, black, green
-    from reportlab.lib.units import inch
-    u = inch/10.0
-    canvas.setLineWidth(4)
-    if debug:
-        canvas.scale(2.8,2.8) # make it big
-        canvas.setLineWidth(1) # small lines
-    canvas.setStrokeColor(black)
-    canvas.setFillColor(tan)
-    p = canvas.beginPath()
-    p.moveTo(10*u,0)
-    p.lineTo(0,5*u)
-    p.lineTo(10*u,10*u)
-    p.curveTo(11.5*u,10*u, 11.5*u,7.5*u, 10*u,7.5*u)
-    p.curveTo(12*u,7.5*u, 11*u,2.5*u, 9.7*u,2.5*u)
-    p.curveTo(10.5*u,2.5*u, 11*u,0, 10*u,0)
-    canvas.drawPath(p, stroke=1, fill=1)
-    canvas.setFillColor(black)
-    p = canvas.beginPath()
-    p.moveTo(0,5*u)
-    p.lineTo(4*u,3*u)
-    p.lineTo(5*u,4.5*u)
-    p.lineTo(3*u,6.5*u)
-    canvas.drawPath(p, stroke=1, fill=1)
-    if debug:
-        canvas.setStrokeColor(green) # put in a frame of reference
-        canvas.grid([0,5*u,10*u,15*u], [0,5*u,10*u])
-"""
-
-testnoteannotation = """
-from reportlab.platypus.flowables import Flowable
-class NoteAnnotation(Flowable):
-    '''put a pencil in the margin.'''
-    def wrap(self, *args):
-        return (1,10) # I take up very little space! (?)
-    def draw(self):
-        canvas = self.canv
-        canvas.translate(-10,-10)
-        canvas.rotate(180)
-        canvas.scale(0.2,0.2)
-        pencil(canvas, text="NOTE")
-"""
-
-testhandannotation = """
-from reportlab.platypus.flowables import Flowable
-from reportlab.lib.colors import tan, green
-class HandAnnotation(Flowable):
-    '''A hand flowable.'''
-    def __init__(self, xoffset=0, size=None, fillcolor=tan, strokecolor=green):
-        from reportlab.lib.units import inch
-        if size is None: size=4*inch
-        self.fillcolor, self.strokecolor = fillcolor, strokecolor
-        self.xoffset = xoffset
-        self.size = size
-        # normal size is 4 inches
-        self.scale = size/(4.0*inch)
-    def wrap(self, *args):
-        return (self.xoffset, self.size)
-    def draw(self):
-        canvas = self.canv
-        canvas.setLineWidth(6)
-        canvas.setFillColor(self.fillcolor)
-        canvas.setStrokeColor(self.strokecolor)
-        canvas.translate(self.xoffset+self.size,0)
-        canvas.rotate(90)
-        canvas.scale(self.scale, self.scale)
-        hand(canvas, debug=0, fill=1)
-"""
-
-lyrics = '''\
-well she hit Net Solutions
-and she registered her own .com site now
-and filled it up with yahoo profile pics
-she snarfed in one night now
-and she made 50 million when Hugh Hefner
-bought up the rights now
-and she'll have fun fun fun
-til her Daddy takes the keyboard away'''
-
-lyrics = string.split(lyrics, "\n")
-testtextsize = """
-def textsize(canvas):
-    from reportlab.lib.units import inch
-    from reportlab.lib.colors import magenta, red
-    canvas.setFont("Times-Roman", 20)
-    canvas.setFillColor(red)
-    canvas.drawCentredString(2.75*inch, 2.5*inch, "Font size examples")
-    canvas.setFillColor(magenta)
-    size = 7
-    y = 2.3*inch
-    x = 1.3*inch
-    for line in lyrics:
-        canvas.setFont("Helvetica", size)
-        canvas.drawRightString(x,y,"%s points: " % size)
-        canvas.drawString(x,y, line)
-        y = y-size*1.2
-        size = size+1.5
-"""
-
-teststar = """
-def star(canvas, title="Title Here", aka="Comment here.",
-         xcenter=None, ycenter=None, nvertices=5):
-    from math import pi
-    from reportlab.lib.units import inch
-    radius=inch/3.0
-    if xcenter is None: xcenter=2.75*inch
-    if ycenter is None: ycenter=1.5*inch
-    canvas.drawCentredString(xcenter, ycenter+1.3*radius, title)
-    canvas.drawCentredString(xcenter, ycenter-1.4*radius, aka)
-    p = canvas.beginPath()
-    p.moveTo(xcenter,ycenter+radius)
-    from math import pi, cos, sin
-    angle = (2*pi)*2/5.0
-    startangle = pi/2.0
-    for vertex in range(nvertices-1):
-        nextangle = angle*(vertex+1)+startangle
-        x = xcenter + radius*cos(nextangle)
-        y = ycenter + radius*sin(nextangle)
-        p.lineTo(x,y)
-    if nvertices==5:
-       p.close()
-    canvas.drawPath(p)
-"""
-
-testjoins = """
-def joins(canvas):
-    from reportlab.lib.units import inch
-    # make lines big
-    canvas.setLineWidth(5)
-    star(canvas, "Default: mitered join", "0: pointed", xcenter = 1*inch)
-    canvas.setLineJoin(1)
-    star(canvas, "Round join", "1: rounded")
-    canvas.setLineJoin(2)
-    star(canvas, "Bevelled join", "2: square", xcenter=4.5*inch)
-"""
-
-testcaps = """
-def caps(canvas):
-    from reportlab.lib.units import inch
-    # make lines big
-    canvas.setLineWidth(5)
-    star(canvas, "Default", "no projection",xcenter = 1*inch,
-         nvertices=4)
-    canvas.setLineCap(1)
-    star(canvas, "Round cap", "1: ends in half circle", nvertices=4)
-    canvas.setLineCap(2)
-    star(canvas, "Square cap", "2: projects out half a width", xcenter=4.5*inch,
-       nvertices=4)
-"""
-
-testdashes = """
-def dashes(canvas):
-    from reportlab.lib.units import inch
-    # make lines big
-    canvas.setDash(6,3)
-    star(canvas, "Simple dashes", "6 points on, 3 off", xcenter = 1*inch)
-    canvas.setDash(1,2)
-    star(canvas, "Dots", "One on, two off")
-    canvas.setDash([1,1,3,3,1,4,4,1], 0)
-    star(canvas, "Complex Pattern", "[1,1,3,3,1,4,4,1]", xcenter=4.5*inch)
-"""
-
-testcursormoves1 = """
-def cursormoves1(canvas):
-    from reportlab.lib.units import inch
-    textobject = canvas.beginText()
-    textobject.setTextOrigin(inch, 2.5*inch)
-    textobject.setFont("Helvetica-Oblique", 14)
-    for line in lyrics:
-        textobject.textLine(line)
-    textobject.setFillGray(0.4)
-    textobject.textLines('''
-    With many apologies to the Beach Boys
-    and anyone else who finds this objectionable
-    ''')
-    canvas.drawText(textobject)
-"""
-
-testcursormoves2 = """
-def cursormoves2(canvas):
-    from reportlab.lib.units import inch
-    textobject = canvas.beginText()
-    textobject.setTextOrigin(2, 2.5*inch)
-    textobject.setFont("Helvetica-Oblique", 14)
-    for line in lyrics:
-        textobject.textOut(line)
-        textobject.moveCursor(14,14) # POSITIVE Y moves down!!!
-    textobject.setFillColorRGB(0.4,0,1)
-    textobject.textLines('''
-    With many apologies to the Beach Boys
-    and anyone else who finds this objectionable
-    ''')
-    canvas.drawText(textobject)
-"""
-
-testcharspace = """
-def charspace(canvas):
-    from reportlab.lib.units import inch
-    textobject = canvas.beginText()
-    textobject.setTextOrigin(3, 2.5*inch)
-    textobject.setFont("Helvetica-Oblique", 10)
-    charspace = 0
-    for line in lyrics:
-        textobject.setCharSpace(charspace)
-        textobject.textLine("%s: %s" %(charspace,line))
-        charspace = charspace+0.5
-    textobject.setFillGray(0.4)
-    textobject.textLines('''
-    With many apologies to the Beach Boys
-    and anyone else who finds this objectionable
-    ''')
-    canvas.drawText(textobject)
-"""
-
-testwordspace = """
-def wordspace(canvas):
-    from reportlab.lib.units import inch
-    textobject = canvas.beginText()
-    textobject.setTextOrigin(3, 2.5*inch)
-    textobject.setFont("Helvetica-Oblique", 12)
-    wordspace = 0
-    for line in lyrics:
-        textobject.setWordSpace(wordspace)
-        textobject.textLine("%s: %s" %(wordspace,line))
-        wordspace = wordspace+2.5
-    textobject.setFillColorCMYK(0.4,0,0.4,0.2)
-    textobject.textLines('''
-    With many apologies to the Beach Boys
-    and anyone else who finds this objectionable
-    ''')
-    canvas.drawText(textobject)
-"""
-testhorizontalscale = """
-def horizontalscale(canvas):
-    from reportlab.lib.units import inch
-    textobject = canvas.beginText()
-    textobject.setTextOrigin(3, 2.5*inch)
-    textobject.setFont("Helvetica-Oblique", 12)
-    horizontalscale = 80 # 100 is default
-    for line in lyrics:
-        textobject.setHorizScale(horizontalscale)
-        textobject.textLine("%s: %s" %(horizontalscale,line))
-        horizontalscale = horizontalscale+10
-    textobject.setFillColorCMYK(0.0,0.4,0.4,0.2)
-    textobject.textLines('''
-    With many apologies to the Beach Boys
-    and anyone else who finds this objectionable
-    ''')
-    canvas.drawText(textobject)
-"""
-testleading = """
-def leading(canvas):
-    from reportlab.lib.units import inch
-    textobject = canvas.beginText()
-    textobject.setTextOrigin(3, 2.5*inch)
-    textobject.setFont("Helvetica-Oblique", 14)
-    leading = 8
-    for line in lyrics:
-        textobject.setLeading(leading)
-        textobject.textLine("%s: %s" %(leading,line))
-        leading = leading+2.5
-    textobject.setFillColorCMYK(0.8,0,0,0.3)
-    textobject.textLines('''
-    With many apologies to the Beach Boys
-    and anyone else who finds this objectionable
-    ''')
-    canvas.drawText(textobject)
-"""
-
-testhand = """
-def hand(canvas, debug=1, fill=0):
-    (startx, starty) = (0,0)
-    curves = [
-      ( 0, 2), ( 0, 4), ( 0, 8), # back of hand
-      ( 5, 8), ( 7,10), ( 7,14),
-      (10,14), (10,13), ( 7.5, 8), # thumb
-      (13, 8), (14, 8), (17, 8),
-      (19, 8), (19, 6), (17, 6),
-      (15, 6), (13, 6), (11, 6), # index, pointing
-      (12, 6), (13, 6), (14, 6),
-      (16, 6), (16, 4), (14, 4),
-      (13, 4), (12, 4), (11, 4), # middle
-      (11.5, 4), (12, 4), (13, 4),
-      (15, 4), (15, 2), (13, 2),
-      (12.5, 2), (11.5, 2), (11, 2), # ring
-      (11.5, 2), (12, 2), (12.5, 2),
-      (14, 2), (14, 0), (12.5, 0),
-      (10, 0), (8, 0), (6, 0), # pinky, then close
-      ]
-    from reportlab.lib.units import inch
-    if debug: canvas.setLineWidth(6)
-    u = inch*0.2
-    p = canvas.beginPath()
-    p.moveTo(startx, starty)
-    ccopy = list(curves)
-    while ccopy:
-        [(x1,y1), (x2,y2), (x3,y3)] = ccopy[:3]
-        del ccopy[:3]
-        p.curveTo(x1*u,y1*u,x2*u,y2*u,x3*u,y3*u)
-    p.close()
-    canvas.drawPath(p, fill=fill)
-    if debug:
-        from reportlab.lib.colors import red, green
-        (lastx, lasty) = (startx, starty)
-        ccopy = list(curves)
-        while ccopy:
-            [(x1,y1), (x2,y2), (x3,y3)] = ccopy[:3]
-            del ccopy[:3]
-            canvas.setStrokeColor(red)
-            canvas.line(lastx*u,lasty*u, x1*u,y1*u)
-            canvas.setStrokeColor(green)
-            canvas.line(x2*u,y2*u, x3*u,y3*u)
-            (lastx,lasty) = (x3,y3)
-"""
-
-testhand2 = """
-def hand2(canvas):
-    canvas.translate(20,10)
-    canvas.setLineWidth(3)
-    canvas.setFillColorRGB(0.1, 0.3, 0.9)
-    canvas.setStrokeGray(0.5)
-    hand(canvas, debug=0, fill=1)
-"""
-
-testfonts = """
-def fonts(canvas):
-    from reportlab.lib.units import inch
-    text = "Now is the time for all good men to..."
-    x = 1.8*inch
-    y = 2.7*inch
-    for font in canvas.getAvailableFonts():
-        canvas.setFont(font, 10)
-        canvas.drawString(x,y,text)
-        canvas.setFont("Helvetica", 10)
-        canvas.drawRightString(x-10,y, font+":")
-        y = y-13
-"""
-
-testarcs = """
-def arcs(canvas):
-    from reportlab.lib.units import inch
-    canvas.setLineWidth(4)
-    canvas.setStrokeColorRGB(0.8, 1, 0.6)
-    # draw rectangles enclosing the arcs
-    canvas.rect(inch, inch, 1.5*inch, inch)
-    canvas.rect(3*inch, inch, inch, 1.5*inch)
-    canvas.setStrokeColorRGB(0, 0.2, 0.4)
-    canvas.setFillColorRGB(1, 0.6, 0.8)
-    p = canvas.beginPath()
-    p.moveTo(0.2*inch, 0.2*inch)
-    p.arcTo(inch, inch, 2.5*inch,2*inch, startAng=-30, extent=135)
-    p.arc(3*inch, inch, 4*inch, 2.5*inch, startAng=-45, extent=270)
-    canvas.drawPath(p, fill=1, stroke=1)
-"""
-testvariousshapes = """
-def variousshapes(canvas):
-    from reportlab.lib.units import inch
-    inch = int(inch)
-    canvas.setStrokeGray(0.5)
-    canvas.grid(range(0,11*inch/2,inch/2), range(0,7*inch/2,inch/2))
-    canvas.setLineWidth(4)
-    canvas.setStrokeColorRGB(0, 0.2, 0.7)
-    canvas.setFillColorRGB(1, 0.6, 0.8)
-    p = canvas.beginPath()
-    p.rect(0.5*inch, 0.5*inch, 0.5*inch, 2*inch)
-    p.circle(2.75*inch, 1.5*inch, 0.3*inch)
-    p.ellipse(3.5*inch, 0.5*inch, 1.2*inch, 2*inch)
-    canvas.drawPath(p, fill=1, stroke=1)
-"""
-
-testclosingfigures = """
-def closingfigures(canvas):
-    from reportlab.lib.units import inch
-    h = inch/3.0; k = inch/2.0
-    canvas.setStrokeColorRGB(0.2,0.3,0.5)
-    canvas.setFillColorRGB(0.8,0.6,0.2)
-    canvas.setLineWidth(4)
-    p = canvas.beginPath()
-    for i in (1,2,3,4):
-        for j in (1,2):
-            xc,yc = inch*i, inch*j
-            p.moveTo(xc,yc)
-            p.arcTo(xc-h, yc-k, xc+h, yc+k, startAng=0, extent=60*i)
-            # close only the first one, not the second one
-            if j==1:
-                p.close()
-    canvas.drawPath(p, fill=1, stroke=1)
-"""
-
-testforms = """
-def forms(canvas):
-    #first create a form...
-    canvas.beginForm("SpumoniForm")
-    #re-use some drawing functions from earlier
-    spumoni(canvas)
-    canvas.endForm()
-
-    #then draw it
-    canvas.doForm("SpumoniForm")
-"""
-
-def doctemplateillustration(canvas):
-    from reportlab.lib.units import inch
-    canvas.setFont("Helvetica", 10)
-    canvas.drawString(inch/4.0, 2.75*inch, "DocTemplate")
-    W = 4/3.0*inch
-    H = 2*inch
-    Wd = x = inch/4.0
-    Hd =y = inch/2.0
-    for name in ("two column", "chapter page", "title page"):
-        canvas.setFillColorRGB(0.5,1.0,1.0)
-        canvas.rect(x,y,W,H, fill=1)
-        canvas.setFillColorRGB(0,0,0)
-        canvas.drawString(x+inch/8, y+H-Wd, "PageTemplate")
-        canvas.drawCentredString(x+W/2.0, y-Wd, name)
-        x = x+W+Wd
-    canvas.saveState()
-    d = inch/16
-    dW = (W-3*d)/2.0
-    hD = H -2*d-Wd
-    canvas.translate(Wd+d, Hd+d)
-    for name in ("left Frame", "right Frame"):
-        canvas.setFillColorRGB(1.0,0.5,1.0)
-        canvas.rect(0,0, dW,hD, fill=1)
-        canvas.setFillGray(0.7)
-        dd= d/2.0
-        ddH = (hD-6*dd)/5.0
-        ddW = dW-2*dd
-        yy = dd
-        xx = dd
-        for i in range(5):
-            canvas.rect(xx,yy,ddW,ddH, fill=1, stroke=0)
-            yy = yy+ddH+dd
-        canvas.setFillColorRGB(0,0,0)
-        canvas.saveState()
-        canvas.rotate(90)
-        canvas.drawString(d,-dW/2, name)
-        canvas.restoreState()
-        canvas.translate(dW+d,0)
-    canvas.restoreState()
-    canvas.setFillColorRGB(1.0, 0.5, 1.0)
-    mx = Wd+W+Wd+d
-    my = Hd+d
-    mW = W-2*d
-    mH = H-d-Hd
-    canvas.rect(mx, my, mW, mH, fill=1)
-    canvas.rect(Wd+2*(W+Wd)+d, Hd+3*d, W-2*d, H/2.0, fill=1)
-    canvas.setFillGray(0.7)
-    canvas.rect(Wd+2*(W+Wd)+d+dd, Hd+5*d, W-2*d-2*dd, H/2.0-2*d-dd, fill=1)
-    xx = mx+dd
-    yy = my+mH/5.0
-    ddH = (mH-6*dd-mH/5.0)/3.0
-    ddW = mW - 2*dd
-    for i in range(3):
-        canvas.setFillGray(0.7)
-        canvas.rect(xx,yy,ddW,ddH, fill=1, stroke=1)
-        canvas.setFillGray(0)
-        canvas.drawString(xx+dd/2.0,yy+dd/2.0, "flowable %s" %(157-i))
-        yy = yy+ddH+dd
-    canvas.drawCentredString(3*Wd+2*W+W/2, Hd+H/2.0, "First Flowable")
-    canvas.setFont("Times-BoldItalic", 8)
-    canvas.setFillGray(0)
-    canvas.drawCentredString(mx+mW/2.0, my+mH+3*dd, "Chapter 6: Lubricants")
-    canvas.setFont("Times-BoldItalic", 10)
-    canvas.drawCentredString(3*Wd+2*W+W/2, Hd+H-H/4, "College Life")
-
-class PlatIllust:
-    #wrap the above for PP#
-    def __init__(self, x, y, scale=1):
-        self.x = x
-        self.y = y
-        self.scale = scale
-    def drawOn(self, canvas):
-        canvas.saveState()
-        canvas.translate(self.x, self.y)
-        canvas.scale(self.scale, self.scale)
-        doctemplateillustration(canvas)
-        canvas.restoreState()
-
-class PingoIllust:
-    #wrap the above for PP#
-    def __init__(self, x, y, scale=1):
-##        print 'Pingo illustration %f, %f, %f' % (x,y,scale)
-        self.x = x
-        self.y = y
-        self.scale = scale
-    def drawOn(self, canvas):
-        canvas.rect(self.x, self.y, 100,100, stroke=1, fill=1)
-##        from pingo import testdrawings
-##        from pingo import pingopdf
-##        drawing = testdrawings.getDrawing3()
-##        canvas.saveState()
-##        canvas.scale(self.scale, self.scale)
-##        pingopdf.draw(drawing, canvas, self.x, self.y)
-##        canvas.restoreState()
-
-# D = dir()
-g = globals()
-Dprime = {}
-from types import StringType
-from string import strip
-for (a,b) in g.items():
-    if a[:4]=="test" and type(b) is StringType:
-        #print 'for', a
-        #print b
-        b = strip(b)
-        exec(b+'\n')
-
-platypussetup = """
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
-from reportlab.lib.styles import getSampleStyleSheet
-from reportlab.lib.pagesizes import DEFAULT_PAGE_SIZE
-from reportlab.lib.units import inch
-PAGE_HEIGHT=DEFAULT_PAGE_SIZE[1]; PAGE_WIDTH=DEFAULT_PAGE_SIZE[0]
-styles = getSampleStyleSheet()
-"""
-platypusfirstpage = """
-Title = "Hello world"
-pageinfo = "platypus example"
-def myFirstPage(canvas, doc):
-    canvas.saveState()
-    canvas.setFont('Times-Bold',16)
-    canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT-108, Title)
-    canvas.setFont('Times-Roman',9)
-    canvas.drawString(inch, 0.75 * inch, "First Page / %s" % pageinfo)
-    canvas.restoreState()
-"""
-platypusnextpage = """
-def myLaterPages(canvas, doc):
-    canvas.saveState()
-    canvas.setFont('Times-Roman',9)
-    canvas.drawString(inch, 0.75 * inch, "Page %d %s" % (doc.page, pageinfo))
-    canvas.restoreState()
-"""
-platypusgo = """
-def go():
-    doc = SimpleDocTemplate("phello.pdf")
-    Story = [Spacer(1,2*inch)]
-    style = styles["Normal"]
-    for i in range(100):
-        bogustext = ("This is Paragraph number %s.  " % i) *20
-        p = Paragraph(bogustext, style)
-        Story.append(p)
-        Story.append(Spacer(1,0.2*inch))
-    doc.build(Story, onFirstPage=myFirstPage, onLaterPages=myLaterPages)
-"""
-
-if __name__=="__main__":
-    # then do the platypus hello world
-    for b in platypussetup, platypusfirstpage, platypusnextpage, platypusgo:
-        b = strip(b)
-        exec(b+'\n')
-    go()