1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
#Copyright ReportLab Europe Ltd. 2000-2004
#see license.txt for license details
#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/test/test_platypus_toc.py
"""Tests for the Platypus TableOfContents class.
Currently there is only one such test. Most such tests, like this
one, will be generating a PDF document that needs to be eye-balled
in order to find out if it is 'correct'.
"""
import sys, os
from os.path import join, basename, splitext
from math import sqrt
from reportlab.test import unittest
from reportlab.test.utils import makeSuiteForClasses, outputfile
from reportlab.lib.units import inch, cm
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.platypus.paragraph import Paragraph
from reportlab.platypus.xpreformatted import XPreformatted
from reportlab.platypus.frames import Frame
from reportlab.platypus.doctemplate \
import PageTemplate, BaseDocTemplate
from reportlab.platypus import tableofcontents
from reportlab.platypus.tableofcontents import TableOfContents
from reportlab.platypus.tables import TableStyle, Table
from reportlab.lib import randomtext
def myMainPageFrame(canvas, doc):
"The page frame used for all PDF documents."
canvas.saveState()
canvas.rect(2.5*cm, 2.5*cm, 15*cm, 25*cm)
canvas.setFont('Times-Roman', 12)
pageNumber = canvas.getPageNumber()
canvas.drawString(10*cm, cm, str(pageNumber))
canvas.restoreState()
class MyDocTemplate(BaseDocTemplate):
"The document template used for all PDF documents."
_invalidInitArgs = ('pageTemplates',)
def __init__(self, filename, **kw):
frame1 = Frame(2.5*cm, 2.5*cm, 15*cm, 25*cm, id='F1')
self.allowSplitting = 0
apply(BaseDocTemplate.__init__, (self, filename), kw)
template = PageTemplate('normal', [frame1], myMainPageFrame)
self.addPageTemplates(template)
def afterFlowable(self, flowable):
"Registers TOC entries and makes outline entries."
if flowable.__class__.__name__ == 'Paragraph':
styleName = flowable.style.name
if styleName[:7] == 'Heading':
# Register TOC entries.
level = int(styleName[7:])
text = flowable.getPlainText()
pageNum = self.page
self.notify('TOCEntry', (level, text, pageNum))
# Add PDF outline entries (not really needed/tested here).
key = str(hash(flowable))
c = self.canv
c.bookmarkPage(key)
c.addOutlineEntry(text, key, level=level, closed=0)
def makeHeaderStyle(level, fontName='Times-Roman'):
"Make a header style for different levels."
assert level >= 0, "Level must be >= 0."
PS = ParagraphStyle
size = 24.0 / sqrt(1+level)
style = PS(name = 'Heading' + str(level),
fontName = fontName,
fontSize = size,
leading = size*1.2,
spaceBefore = size/4.0,
spaceAfter = size/8.0)
return style
def makeBodyStyle():
"Body text style - the default will do"
return ParagraphStyle('body')
def makeTocHeaderStyle(level, delta, epsilon, fontName='Times-Roman'):
"Make a header style for different levels."
assert level >= 0, "Level must be >= 0."
PS = ParagraphStyle
size = 12
style = PS(name = 'Heading' + str(level),
fontName = fontName,
fontSize = size,
leading = size*1.2,
spaceBefore = size/4.0,
spaceAfter = size/8.0,
firstLineIndent = -epsilon,
leftIndent = level*delta + epsilon)
return style
class TocTestCase(unittest.TestCase):
"Test TableOfContents class (eyeball-test)."
def test0(self):
"""Test story with TOC and a cascaded header hierarchy.
The story should contain exactly one table of contents that is
immediatly followed by a list of of cascaded levels of header
lines, each nested one level deeper than the previous one.
Features to be visually confirmed by a human being are:
1. TOC lines are indented in multiples of 1 cm.
2. Wrapped TOC lines continue with additional 0.5 cm indentation.
3. ...
"""
maxLevels = 12
# Create styles to be used for document headers
# on differnet levels.
headerLevelStyles = []
for i in range(maxLevels):
headerLevelStyles.append(makeHeaderStyle(i))
# Create styles to be used for TOC entry lines
# for headers on differnet levels.
tocLevelStyles = []
d, e = tableofcontents.delta, tableofcontents.epsilon
for i in range(maxLevels):
tocLevelStyles.append(makeTocHeaderStyle(i, d, e))
# Build story.
story = []
styleSheet = getSampleStyleSheet()
bt = styleSheet['BodyText']
description = '<font color=red>%s</font>' % self.test0.__doc__
story.append(XPreformatted(description, bt))
toc = TableOfContents()
toc.levelStyles = tocLevelStyles
story.append(toc)
for i in range(maxLevels):
story.append(Paragraph('HEADER, LEVEL %d' % i,
headerLevelStyles[i]))
#now put some body stuff in.
txt = randomtext.randomText(randomtext.PYTHON, 5)
para = Paragraph(txt, makeBodyStyle())
story.append(para)
path = outputfile('test_platypus_toc.pdf')
doc = MyDocTemplate(path)
doc.multiBuild(story)
def makeSuite():
return makeSuiteForClasses(TocTestCase)
#noruntests
if __name__ == "__main__":
unittest.TextTestRunner().run(makeSuite())
|
