842 lines
26 KiB
Python
842 lines
26 KiB
Python
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()
|