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 | """Draws a specification sheet whose cells are merged down the rows.
The Python twin of the `write_merged_cells` example in Rust. Each group of
properties names itself once, in a cell covering all the rows of the group, and
carries one note beside them in another: the rows beneath hand their cells to
the columns those two leave free, and the hairlines between the rows stop at
their edges. The last group shows what a merged cell does when it needs more
room than its rows give it: every row it covers grows by the same share of what
is missing.
Every word the sheet draws is held in `Words`, once per language, and `HQF_PDF_LANG`
picks which one is drawn. The model's number and the figures are the same in both.
Usage: python examples/write_merged_cells.py [out.pdf] [font.ttf]
HQF_PDF_LANG=fr python examples/write_merged_cells.py
"""
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
import _language
import _licence
import _out
import hqf_pdf
# The margins, and the box the table is fitted into.
MARGIN = 56.0
TOP = 760.0
BOTTOM = 64.0
PAGE_WIDTH = 595.276
TABLE_WIDTH = PAGE_WIDTH - 2 * MARGIN
# The colour a group's name and its note are painted on.
GROUP_FILL = hqf_pdf.Rgb(0.90, 0.91, 0.94)
# How many properties each group holds, in the order they are printed.
GROUP_ROWS = (4, 3, 2, 2)
@dataclass(frozen=True)
class Words:
"""Every word the sheet draws, in one language.
What is not language stays out of it: the model's number, the figures and the units
they are given in read the same in every language.
"""
# The heading across the four columns.
title: str
# What each group is called, written once beside all of its rows.
groups: tuple[str, ...]
# What is said about each group as a whole, once beside all of its rows. The last is
# far longer than the two rows it covers, which is what makes the sheet's last row
# grow.
notes: tuple[str, ...]
# What each property is called, group after group.
properties: tuple[str, ...]
# What each of them is worth, in the same order.
values: tuple[str, ...]
# The sheet in English.
ENGLISH = Words(
title="Model HQF-220 — technical data",
groups=("Body", "Optics", "Mounting", "Power"),
notes=(
"Measured without the mounting plate.",
"Figures hold across the whole of the zoom range.",
"Plate sold with the instrument.",
"Twelve volts, from the adapter supplied or from any regulated bench "
"supply. The instrument draws its full current for the first two seconds "
"after it is switched on, so a supply rated at the working figure alone "
"will trip.",
),
properties=(
"Material",
"Mass",
"Finish",
"Sealing",
"Focal length",
"Widest aperture",
"Coating",
"Thread",
"Plate",
"Supply",
"Draw",
),
values=(
"Anodised aluminium",
"1.84 kg",
"Matt black, bead blasted",
"IP65",
"24 to 70 mm",
"f/2.8",
"Multi-layer, both faces",
"M6, four points",
"Quick release",
"12 V DC",
"9 W at full output",
),
)
# The sheet in French.
FRENCH = Words(
title="Modèle HQF-220 — caractéristiques techniques",
groups=("Boîtier", "Optique", "Fixation", "Alimentation"),
notes=(
"Mesuré sans la platine de fixation.",
"Valeurs valables sur toute la plage de zoom.",
"Platine livrée avec l'appareil.",
"Douze volts, par l'adaptateur fourni ou par toute alimentation de "
"laboratoire régulée. L'appareil appelle son courant maximal pendant "
"les deux premières secondes après la mise sous tension : une "
"alimentation calibrée sur la seule valeur nominale déclenchera.",
),
properties=(
"Matériau",
"Masse",
"Finition",
"Étanchéité",
"Focale",
"Ouverture maximale",
"Traitement",
"Filetage",
"Platine",
"Source",
"Consommation",
),
values=(
"Aluminium anodisé",
"1.84 kg",
"Noir mat, microbillé",
"IP65",
"24 à 70 mm",
"f/2.8",
"Multicouche, deux faces",
"M6, quatre points",
"Attache rapide",
"12 V continu",
"9 W à pleine puissance",
),
)
# Every language the example is written in. A language is added by writing its own set
# of words and naming it here.
WORDS = {_language.ENGLISH: ENGLISH, _language.FRENCH: FRENCH}
def sheet(font: hqf_pdf.FontHandle, words: Words) -> hqf_pdf.Table:
"""The specification sheet: a heading across the table, then two merged
cells per group of properties."""
# The property column takes whatever the other three leave it.
columns = hqf_pdf.Columns(
[
hqf_pdf.ColumnWidth.points(76.0),
hqf_pdf.ColumnWidth.fraction(1.0),
hqf_pdf.ColumnWidth.points(120.0),
hqf_pdf.ColumnWidth.points(150.0),
],
TABLE_WIDTH,
)
table = hqf_pdf.Table(columns)
table.header(1)
table.rule(hqf_pdf.Rule.frame(), hqf_pdf.Stroke(0.8))
hairline = hqf_pdf.Stroke(0.25, hqf_pdf.Rgb.gray(0.75))
table.rule(hqf_pdf.Rule.horizontal_other(), hairline)
table.rule(hqf_pdf.Rule.vertical_other(), hairline)
table.rule(hqf_pdf.Rule.horizontal(1), hqf_pdf.Stroke(0.8))
pad = hqf_pdf.Padding.symmetric(6.0, 5.0)
# The heading covers the four columns, the way a cell covers four rows further down:
# one span across, one down.
table.push(
hqf_pdf.Row(
[
hqf_pdf.Cell(
font,
11.0,
words.title,
span=4,
align=hqf_pdf.Align.Center,
valign=hqf_pdf.VAlign.Middle,
padding=pad,
fill=hqf_pdf.Rgb.gray(0.86),
)
],
min_height=24.0,
)
)
first = 0
for group, rows in enumerate(GROUP_ROWS):
for index in range(rows):
prop = words.properties[first + index]
value = words.values[first + index]
cells = []
# The group names itself on its first row only, and so does its note. The
# rows under them hold two cells, not four: the first column and the last
# are taken.
if index == 0:
cells.append(
hqf_pdf.Cell(
font,
10.0,
words.groups[group],
span_rows=rows,
align=hqf_pdf.Align.Center,
valign=hqf_pdf.VAlign.Middle,
padding=pad,
fill=GROUP_FILL,
)
)
cells.append(hqf_pdf.Cell(font, 9.0, prop, padding=pad))
cells.append(hqf_pdf.Cell(font, 9.0, value, padding=pad))
if index == 0:
cells.append(
hqf_pdf.Cell(
font,
8.0,
words.notes[group],
span_rows=rows,
align=hqf_pdf.Align.Justify,
padding=pad,
fill=GROUP_FILL,
)
)
table.push(hqf_pdf.Row(cells, min_height=18.0))
first += rows
return table
def main() -> None:
language = _language.from_environment()
words = _language.words_of(WORDS, language)
# A named file is written as named; the default one carries the language, so the two
# languages do not overwrite each other in `tmp/`.
out = _out.output_path(Path(_language.file_name("merged_cells.pdf", language)).stem)
document = hqf_pdf.Document()
document.set_license(_licence.licensed())
font = document.add_font(hqf_pdf.Font.from_path(_out.font_path()))
table = sheet(font, words)
placed = table.fit(MARGIN, TOP, TOP - BOTTOM, 0)
content = hqf_pdf.Content()
placed.draw(content)
page = hqf_pdf.Page.a4()
page.set_content(content)
document.add_page(page)
written = document.write(out)
print(f"wrote {out}: {written} bytes, {table.row_count} rows")
if __name__ == "__main__":
main()
|