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)