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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
import operator, string
from reportlab.platypus import *
#from reportlab import rl_config
from reportlab.lib.styles import PropertySet, getSampleStyleSheet, ParagraphStyle
from reportlab.lib import colors
from reportlab.platypus.paragraph import Paragraph
#from reportlab.lib.utils import fp_str
#from reportlab.pdfbase import pdfmetrics
from reportlab.platypus.flowables import PageBreak
import os
from reportlab.test import unittest
from reportlab.test.utils import makeSuiteForClasses, outputfile
from types import TupleType, ListType, StringType
class TableTestCase(unittest.TestCase):
def getDataBlock(self):
"Helper - data for our spanned table"
return [
# two rows are for headers
['Region','Product','Period',None,None,None,'Total'],
[None,None,'Q1','Q2','Q3','Q4',None],
# now for data
['North','Spam',100,110,120,130,460],
['North','Eggs',101,111,121,131,464],
['North','Guinness',102,112,122,132,468],
['South','Spam',100,110,120,130,460],
['South','Eggs',101,111,121,131,464],
['South','Guinness',102,112,122,132,468],
]
def test_document(self):
rowheights = (24, 16, 16, 16, 16)
rowheights2 = (24, 16, 16, 16, 30)
colwidths = (50, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32)
GRID_STYLE = TableStyle(
[('GRID', (0,0), (-1,-1), 0.25, colors.black),
('ALIGN', (1,1), (-1,-1), 'RIGHT')]
)
styleSheet = getSampleStyleSheet()
styNormal = styleSheet['Normal']
styNormal.spaceBefore = 6
styNormal.spaceAfter = 6
data = (
('', 'Jan', 'Feb', 'Mar','Apr','May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'),
('Mugs', 0, 4, 17, 3, 21, 47, 12, 33, 2, -2, 44, 89),
('T-Shirts', 0, 42, 9, -3, 16, 4, 72, 89, 3, 19, 32, 119),
('Miscellaneous accessories', 0,0,0,0,0,0,1,0,0,0,2,13),
('Hats', 893, 912, '1,212', 643, 789, 159, 888, '1,298', 832, 453, '1,344','2,843')
)
data2 = (
('', 'Jan', 'Feb', 'Mar','Apr','May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'),
('Mugs', 0, 4, 17, 3, 21, 47, 12, 33, 2, -2, 44, 89),
('T-Shirts', 0, 42, 9, -3, 16, 4, 72, 89, 3, 19, 32, 119),
('Key Ring', 0,0,0,0,0,0,1,0,0,0,2,13),
('Hats\nLarge', 893, 912, '1,212', 643, 789, 159, 888, '1,298', 832, 453, '1,344','2,843')
)
data3 = (
('', 'Jan', 'Feb', 'Mar','Apr','May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'),
('Mugs', 0, 4, 17, 3, 21, 47, 12, 33, 2, -2, 44, 89),
('T-Shirts', 0, 42, 9, -3, 16, 4, 72, 89, 3, 19, 32, 119),
('Key Ring', 0,0,0,0,0,0,1,0,0,0,2,13),
(Paragraph("Let's <b>really mess things up with a <i>paragraph</i>",styNormal),
893, 912, '1,212', 643, 789, 159, 888, '1,298', 832, 453, '1,344','2,843')
)
lst = []
lst.append(Paragraph("""Basics about column sizing and cell contents""", styleSheet['Heading1']))
t1 = Table(data, colwidths, rowheights)
t1.setStyle(GRID_STYLE)
lst.append(Paragraph("This is GRID_STYLE with explicit column widths. Each cell contains a string or number\n", styleSheet['BodyText']))
lst.append(t1)
lst.append(Spacer(18,18))
t2 = Table(data, None, None)
t2.setStyle(GRID_STYLE)
lst.append(Paragraph("""This is GRID_STYLE with no size info. It
does the sizes itself, measuring each text string
and computing the space it needs. If the text is
too wide for the frame, the table will overflow
as seen here.""",
styNormal))
lst.append(t2)
lst.append(Spacer(18,18))
t3 = Table(data2, None, None)
t3.setStyle(GRID_STYLE)
lst.append(Paragraph("""This demonstrates the effect of adding text strings with
newlines to a cell. It breaks where you specify, and if rowHeights is None (i.e
automatic) then you'll see the effect. See bottom left cell.""",
styNormal))
lst.append(t3)
lst.append(Spacer(18,18))
colWidths = (None, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32)
t3 = Table(data3, colWidths, None)
t3.setStyle(GRID_STYLE)
lst.append(Paragraph("""This table does not specify the size of the first column,
so should work out a sane one. In this case the element
at bottom left is a paragraph, which has no intrinsic size
(the height and width are a function of each other). So,
it tots up the extra space in the frame and divides it
between any such unsizeable columns. As a result the
table fills the width of the frame (except for the
6 point padding on either size).""",
styNormal))
lst.append(t3)
lst.append(PageBreak())
lst.append(Paragraph("""Row and Column spanning""", styleSheet['Heading1']))
lst.append(Paragraph("""This shows a very basic table. We do a faint pink grid
to show what's behind it - imagine this is not printed, as we'll overlay it later
with some black lines. We're going to "span" some cells, and have put a
value of None in the data to signify the cells we don't care about.
(In real life if you want an empty cell, put '' in it rather than None). """, styNormal))
sty = TableStyle([
#very faint grid to show what's where
('GRID', (0,0), (-1,-1), 0.25, colors.pink),
])
t = Table(self.getDataBlock(), colWidths=None, rowHeights=None, style=sty)
lst.append(t)
lst.append(Paragraph("""We now center the text for the "period"
across the four cells for each quarter. To do this we add a 'span'
command to the style to make the cell at row 1 column 3 cover 4 cells,
and a 'center' command for all cells in the top row. The spanning
is not immediately evident but trust us, it's happening - the word
'Period' is centered across the 4 columns. Note also that the
underlying grid shows through. All line drawing commands apply
to the underlying grid, so you have to take care what you put
grids through.""", styNormal))
sty = TableStyle([
#
('GRID', (0,0), (-1,-1), 0.25, colors.pink),
('ALIGN', (0,0), (-1,0), 'CENTER'),
('SPAN', (2,0), (5,0)),
])
t = Table(self.getDataBlock(), colWidths=None, rowHeights=None, style=sty)
lst.append(t)
lst.append(Paragraph("""We repeat this for the words 'Region', Product'
and 'Total', which each span the top 2 rows; and for 'Nprth' and 'South'
which span 3 rows. At the moment each cell's alignment is the default
(bottom), so these words appear to have "dropped down"; in fact they
are sitting on the bottom of their allocated ranges. You will just see that
all the 'None' values vanished, as those cells are not drawn any more.""", styNormal))
sty = TableStyle([
#
('GRID', (0,0), (-1,-1), 0.25, colors.pink),
('ALIGN', (0,0), (-1,0), 'CENTER'),
('SPAN', (2,0), (5,0)),
#span the other column heads down 2 rows
('SPAN', (0,0), (0,1)),
('SPAN', (1,0), (1,1)),
('SPAN', (6,0), (6,1)),
#span the 'north' and 'south' down 3 rows each
('SPAN', (0,2), (0,4)),
('SPAN', (0,5), (0,7)),
])
t = Table(self.getDataBlock(), colWidths=None, rowHeights=None, style=sty)
lst.append(t)
lst.append(PageBreak())
lst.append(Paragraph("""Now we'll tart things up a bit. First,
we set the vertical alignment of each spanned cell to 'middle'.
Next we add in some line drawing commands which do not slash across
the spanned cells (this needs a bit of work).
Finally we'll add some thicker lines to divide it up, and hide the pink. Voila!
""", styNormal))
sty = TableStyle([
#
# ('GRID', (0,0), (-1,-1), 0.25, colors.pink),
('TOPPADDING', (0,0), (-1,-1), 3),
#span the 'period'
('SPAN', (2,0), (5,0)),
#span the other column heads down 2 rows
('SPAN', (0,0), (0,1)),
('SPAN', (1,0), (1,1)),
('SPAN', (6,0), (6,1)),
#span the 'north' and 'south' down 3 rows each
('SPAN', (0,2), (0,4)),
('SPAN', (0,5), (0,7)),
#top row headings are centred
('ALIGN', (0,0), (-1,0), 'CENTER'),
#everything we span is vertically centred
#span the other column heads down 2 rows
('VALIGN', (0,0), (0,1), 'MIDDLE'),
('VALIGN', (1,0), (1,1), 'MIDDLE'),
('VALIGN', (6,0), (6,1), 'MIDDLE'),
#span the 'north' and 'south' down 3 rows each
('VALIGN', (0,2), (0,4), 'MIDDLE'),
('VALIGN', (0,5), (0,7), 'MIDDLE'),
#numeric stuff right aligned
('ALIGN', (2,1), (-1,-1), 'RIGHT'),
#draw lines carefully so as not to swipe through
#any of the 'spanned' cells
('GRID', (1,2), (-1,-1), 1.0, colors.black),
('BOX', (0,2), (0,4), 1.0, colors.black),
('BOX', (0,5), (0,7), 1.0, colors.black),
('BOX', (0,0), (0,1), 1.0, colors.black),
('BOX', (1,0), (1,1), 1.0, colors.black),
('BOX', (2,0), (5,0), 1.0, colors.black),
('GRID', (2,1), (5,1), 1.0, colors.black),
('BOX', (6,0), (6,1), 1.0, colors.black),
# do fatter boxes around some cells
('BOX', (0,0), (-1,1), 2.0, colors.black),
('BOX', (0,2), (-1,4), 2.0, colors.black),
('BOX', (0,5), (-1,7), 2.0, colors.black),
('BOX', (-1,0), (-1,-1), 2.0, colors.black),
])
t = Table(self.getDataBlock(), colWidths=None, rowHeights=None, style=sty)
lst.append(t)
lst.append(Paragraph("""How cells get sized""", styleSheet['Heading1']))
lst.append(Paragraph("""So far the table has been auto-sized. This can be
computationally expensive, and can lead to yucky effects. Imagine a lot of
numbers, one of which goes to 4 figures - tha numeric column will be wider.
The best approach is to specify the column
widths where you know them, and let the system do the heights. Here we set some
widths - an inch for the text columns and half an inch for the numeric ones.
""", styNormal))
t = Table(self.getDataBlock(),
colWidths=(72,72,36,36,36,36,56),
rowHeights=None,
style=sty)
lst.append(t)
lst.append(Paragraph("""The auto-sized example 2 steps back demonstrates
one advanced feature of the sizing algorithm. In the table below,
the columns for Q1-Q4 should all be the same width. We've made
the text above it a bit longer than "Period". Note that this text
is technically in the 3rd column; on our first implementation this
was sized and column 3 was therefore quite wide. To get it right,
we ensure that any cells which span columns, or which are 'overwritten'
by cells which span columns, are assigned zero width in the cell
sizing. Thus, only the string 'Q1' and the numbers below it are
calculated in estimating the width of column 3, and the phrase
"What time of year?" is not used. However, row-spanned cells are
taken into account. ALL the cells in the leftmost column
have a vertical span (or are occluded by others which do)
but it can still work out a sane width for them.
""", styNormal))
data = self.getDataBlock()
data[0][2] = "Which time of year?"
#data[7][0] = Paragraph("Let's <b>really mess things up with a <i>paragraph</i>",styNormal)
t = Table(data,
#colWidths=(72,72,36,36,36,36,56),
rowHeights=None,
style=sty)
lst.append(t)
lst.append(Paragraph("""Paragraphs and unsizeable objects in table cells.""", styleSheet['Heading1']))
lst.append(Paragraph("""Paragraphs and other flowable objects make table
sizing much harder. In general the height of a paragraph is a function
of its width so you can't ask it how wide it wants to be - and the
REALLY wide all-on-one-line solution is rarely what is wanted. We
refer to Paragraphs and their kin as "unsizeable objects". In this example
we have set the widths of all but the first column. As you can see
it uses all the available space across the page for the first column.
Note also that this fairly large cell does NOT contribute to the
height calculation for its 'row'. Under the hood it is in the
same row as the second Spam, but this row gets a height based on
its own contents and not the cell with the paragraph.
""", styNormal))
data = self.getDataBlock()
data[5][0] = Paragraph("Let's <b>really mess things up</b> with a <i>paragraph</i>, whose height is a function of the width you give it.",styNormal)
t = Table(data,
colWidths=(None,72,36,36,36,36,56),
rowHeights=None,
style=sty)
lst.append(t)
lst.append(Paragraph("""This one demonstrates that our current algorithm
does not cover all cases :-( The height of row 0 is being driven by
the width of the para, which thinks it should fit in 1 column and not 4.
To really get this right would involve multiple passes through all the cells
applying rules until everything which can be sized is sized (possibly
backtracking), applying increasingly dumb and brutal
rules on each pass.
""", styNormal))
data = self.getDataBlock()
data[0][2] = Paragraph("Let's <b>really mess things up</b> with a <i>paragraph</i>.",styNormal)
data[5][0] = Paragraph("Let's <b>really mess things up</b> with a <i>paragraph</i>, whose height is a function of the width you give it.",styNormal)
t = Table(data,
colWidths=(None,72,36,36,36,36,56),
rowHeights=None,
style=sty)
lst.append(t)
lst.append(Paragraph("""To avoid these problems remember the golden rule
of ReportLab tables: (1) fix the widths if you can, (2) don't use
a paragraph when a string will do.
""", styNormal))
SimpleDocTemplate(outputfile('test_table_layout.pdf'), showBoundary=1).build(lst)
def makeSuite():
return makeSuiteForClasses(TableTestCase)
#noruntests
if __name__ == "__main__":
unittest.TextTestRunner().run(makeSuite())
print 'saved '+outputfile('test_table_layout.pdf')
|
