Differential D18735 Diff 51234 src/LineBlockCharacters.cpp

Changeset View

Standalone View

View Options

src/LineBlockCharacters.cpp

  • This file was added.
1​/*
2​ 2018-2019 Mariusz Glebocki <mglb@arccos-1.net>
3​ 2018 Martin T. H. Sandsmark <martin.sandsmark@kde.org>
4​ 2015-2018 Kurt Hindenburg <kurt.hindenburg@gmail.com>
5​ 2005 Maksim Orlovich
6​
7​ This program is free software; you can redistribute it and/or modify
8​ it under the terms of the GNU General Public License as published by
9​ the Free Software Foundation; either version 2 of the License, or
10​ (at your option) any later version.
11​
12​ This program is distributed in the hope that it will be useful,
13​ but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​ GNU General Public License for more details.
16​
17​ You should have received a copy of the GNU General Public License
18​ along with this program; if not, write to the Free Software
19​ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20​ 02110-1301 USA.
21​*/
22​
23​// Own
24​#include "LineBlockCharacters.h"
25​
26​// Qt
27​#include <QPainter>
28​
29​namespace Konsole {
30​namespace LineBlockCharacters {
31​
32​enum LineType {
33​ LtNone = 0,
34​ LtDouble = 1,
35​ LtLight = 2,
36​ LtHeavy = 3,
37​};
38​
39​// PackedLineTypes is an 8-bit number representing types of 4 line character's lines. Each line is
40​// represented by 2 bits. Lines order, starting from MSB: top, right, bottom, left.
41​static inline constexpr quint8 makePackedLineTypes(LineType top, LineType right, LineType bottom, LineType left)
42​{
43​ return (int(top) & 3) << 6 | (int(right) & 3) << 4 | (int(bottom) & 3) << 2 | (int(left) & 3);
44​}
45​
46​static constexpr const quint8 PackedLineTypesLut[] = {
47​ // top right bottom left
48​ makePackedLineTypes(LtNone , LtLight , LtNone , LtLight ), /* U+2500 ─ */
49​ makePackedLineTypes(LtNone , LtHeavy , LtNone , LtHeavy ), /* U+2501 ━ */
50​ makePackedLineTypes(LtLight , LtNone , LtLight , LtNone ), /* U+2502 │ */
51​ makePackedLineTypes(LtHeavy , LtNone , LtHeavy , LtNone ), /* U+2503 ┃ */
52​ 0, 0, 0, 0, 0, 0, 0, 0, /* U+2504-0x250b */
53​ makePackedLineTypes(LtNone , LtLight , LtLight , LtNone ), /* U+250C ┌ */
54​ makePackedLineTypes(LtNone , LtHeavy , LtLight , LtNone ), /* U+250D ┍ */
55​ makePackedLineTypes(LtNone , LtLight , LtHeavy , LtNone ), /* U+250E ┎ */
56​ makePackedLineTypes(LtNone , LtHeavy , LtHeavy , LtNone ), /* U+250F ┏ */
57​ makePackedLineTypes(LtNone , LtNone , LtLight , LtLight ), /* U+2510 ┐ */
58​ makePackedLineTypes(LtNone , LtNone , LtLight , LtHeavy ), /* U+2511 ┑ */
59​ makePackedLineTypes(LtNone , LtNone , LtHeavy , LtLight ), /* U+2512 ┒ */
60​ makePackedLineTypes(LtNone , LtNone , LtHeavy , LtHeavy ), /* U+2513 ┓ */
61​ makePackedLineTypes(LtLight , LtLight , LtNone , LtNone ), /* U+2514 └ */
62​ makePackedLineTypes(LtLight , LtHeavy , LtNone , LtNone ), /* U+2515 ┕ */
63​ makePackedLineTypes(LtHeavy , LtLight , LtNone , LtNone ), /* U+2516 ┖ */
64​ makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtNone ), /* U+2517 ┗ */
65​ makePackedLineTypes(LtLight , LtNone , LtNone , LtLight ), /* U+2518 ┘ */
66​ makePackedLineTypes(LtLight , LtNone , LtNone , LtHeavy ), /* U+2519 ┙ */
67​ makePackedLineTypes(LtHeavy , LtNone , LtNone , LtLight ), /* U+251A ┚ */
68​ makePackedLineTypes(LtHeavy , LtNone , LtNone , LtHeavy ), /* U+251B ┛ */
69​ makePackedLineTypes(LtLight , LtLight , LtLight , LtNone ), /* U+251C ├ */
70​ makePackedLineTypes(LtLight , LtHeavy , LtLight , LtNone ), /* U+251D ┝ */
71​ makePackedLineTypes(LtHeavy , LtLight , LtLight , LtNone ), /* U+251E ┞ */
72​ makePackedLineTypes(LtLight , LtLight , LtHeavy , LtNone ), /* U+251F ┟ */
73​ makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtNone ), /* U+2520 ┠ */
74​ makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtNone ), /* U+2521 ┡ */
75​ makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtNone ), /* U+2522 ┢ */
76​ makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtNone ), /* U+2523 ┣ */
77​ makePackedLineTypes(LtLight , LtNone , LtLight , LtLight ), /* U+2524 ┤ */
78​ makePackedLineTypes(LtLight , LtNone , LtLight , LtHeavy ), /* U+2525 ┥ */
79​ makePackedLineTypes(LtHeavy , LtNone , LtLight , LtLight ), /* U+2526 ┦ */
80​ makePackedLineTypes(LtLight , LtNone , LtHeavy , LtLight ), /* U+2527 ┧ */
81​ makePackedLineTypes(LtHeavy , LtNone , LtHeavy , LtLight ), /* U+2528 ┨ */
82​ makePackedLineTypes(LtHeavy , LtNone , LtLight , LtHeavy ), /* U+2529 ┩ */
83​ makePackedLineTypes(LtLight , LtNone , LtHeavy , LtHeavy ), /* U+252A ┪ */
84​ makePackedLineTypes(LtHeavy , LtNone , LtHeavy , LtHeavy ), /* U+252B ┫ */
85​ makePackedLineTypes(LtNone , LtLight , LtLight , LtLight ), /* U+252C ┬ */
86​ makePackedLineTypes(LtNone , LtLight , LtLight , LtHeavy ), /* U+252D ┭ */
87​ makePackedLineTypes(LtNone , LtHeavy , LtLight , LtLight ), /* U+252E ┮ */
88​ makePackedLineTypes(LtNone , LtHeavy , LtLight , LtHeavy ), /* U+252F ┯ */
89​ makePackedLineTypes(LtNone , LtLight , LtHeavy , LtLight ), /* U+2530 ┰ */
90​ makePackedLineTypes(LtNone , LtLight , LtHeavy , LtHeavy ), /* U+2531 ┱ */
91​ makePackedLineTypes(LtNone , LtHeavy , LtHeavy , LtLight ), /* U+2532 ┲ */
92​ makePackedLineTypes(LtNone , LtHeavy , LtHeavy , LtHeavy ), /* U+2533 ┳ */
93​ makePackedLineTypes(LtLight , LtLight , LtNone , LtLight ), /* U+2534 ┴ */
94​ makePackedLineTypes(LtLight , LtLight , LtNone , LtHeavy ), /* U+2535 ┵ */
95​ makePackedLineTypes(LtLight , LtHeavy , LtNone , LtLight ), /* U+2536 ┶ */
96​ makePackedLineTypes(LtLight , LtHeavy , LtNone , LtHeavy ), /* U+2537 ┷ */
97​ makePackedLineTypes(LtHeavy , LtLight , LtNone , LtLight ), /* U+2538 ┸ */
98​ makePackedLineTypes(LtHeavy , LtLight , LtNone , LtHeavy ), /* U+2539 ┹ */
99​ makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtLight ), /* U+253A ┺ */
100​ makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtHeavy ), /* U+253B ┻ */
101​ makePackedLineTypes(LtLight , LtLight , LtLight , LtLight ), /* U+253C ┼ */
102​ makePackedLineTypes(LtLight , LtLight , LtLight , LtHeavy ), /* U+253D ┽ */
103​ makePackedLineTypes(LtLight , LtHeavy , LtLight , LtLight ), /* U+253E ┾ */
104​ makePackedLineTypes(LtLight , LtHeavy , LtLight , LtHeavy ), /* U+253F ┿ */
105​ makePackedLineTypes(LtHeavy , LtLight , LtLight , LtLight ), /* U+2540 ╀ */
106​ makePackedLineTypes(LtLight , LtLight , LtHeavy , LtLight ), /* U+2541 ╁ */
107​ makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtLight ), /* U+2542 ╂ */
108​ makePackedLineTypes(LtHeavy , LtLight , LtLight , LtHeavy ), /* U+2543 ╃ */
109​ makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtLight ), /* U+2544 ╄ */
110​ makePackedLineTypes(LtLight , LtLight , LtHeavy , LtHeavy ), /* U+2545 ╅ */
111​ makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtLight ), /* U+2546 ╆ */
112​ makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtHeavy ), /* U+2547 ╇ */
113​ makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtHeavy ), /* U+2548 ╈ */
114​ makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtHeavy ), /* U+2549 ╉ */
115​ makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtLight ), /* U+254A ╊ */
116​ makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtHeavy ), /* U+254B ╋ */
117​ 0, 0, 0, 0, /* U+254C - U+254F */
118​ makePackedLineTypes(LtNone , LtDouble, LtNone , LtDouble), /* U+2550 ═ */
119​ makePackedLineTypes(LtDouble, LtNone , LtDouble, LtNone ), /* U+2551 ║ */
120​ makePackedLineTypes(LtNone , LtDouble, LtLight , LtNone ), /* U+2552 ╒ */
121​ makePackedLineTypes(LtNone , LtLight , LtDouble, LtNone ), /* U+2553 ╓ */
122​ makePackedLineTypes(LtNone , LtDouble, LtDouble, LtNone ), /* U+2554 ╔ */
123​ makePackedLineTypes(LtNone , LtNone , LtLight , LtDouble), /* U+2555 ╕ */
124​ makePackedLineTypes(LtNone , LtNone , LtDouble, LtLight ), /* U+2556 ╖ */
125​ makePackedLineTypes(LtNone , LtNone , LtDouble, LtDouble), /* U+2557 ╗ */
126​ makePackedLineTypes(LtLight , LtDouble, LtNone , LtNone ), /* U+2558 ╘ */
127​ makePackedLineTypes(LtDouble, LtLight , LtNone , LtNone ), /* U+2559 ╙ */
128​ makePackedLineTypes(LtDouble, LtDouble, LtNone , LtNone ), /* U+255A ╚ */
129​ makePackedLineTypes(LtLight , LtNone , LtNone , LtDouble), /* U+255B ╛ */
130​ makePackedLineTypes(LtDouble, LtNone , LtNone , LtLight ), /* U+255C ╜ */
131​ makePackedLineTypes(LtDouble, LtNone , LtNone , LtDouble), /* U+255D ╝ */
132​ makePackedLineTypes(LtLight , LtDouble, LtLight , LtNone ), /* U+255E ╞ */
133​ makePackedLineTypes(LtDouble, LtLight , LtDouble, LtNone ), /* U+255F ╟ */
134​ makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtNone ), /* U+2560 ╠ */
135​ makePackedLineTypes(LtLight , LtNone , LtLight , LtDouble), /* U+2561 ╡ */
136​ makePackedLineTypes(LtDouble, LtNone , LtDouble, LtLight ), /* U+2562 ╢ */
137​ makePackedLineTypes(LtDouble, LtNone , LtDouble, LtDouble), /* U+2563 ╣ */
138​ makePackedLineTypes(LtNone , LtDouble, LtLight , LtDouble), /* U+2564 ╤ */
139​ makePackedLineTypes(LtNone , LtLight , LtDouble, LtLight ), /* U+2565 ╥ */
140​ makePackedLineTypes(LtNone , LtDouble, LtDouble, LtDouble), /* U+2566 ╦ */
141​ makePackedLineTypes(LtLight , LtDouble, LtNone , LtDouble), /* U+2567 ╧ */
142​ makePackedLineTypes(LtDouble, LtLight , LtNone , LtLight ), /* U+2568 ╨ */
143​ makePackedLineTypes(LtDouble, LtDouble, LtNone , LtDouble), /* U+2569 ╩ */
144​ makePackedLineTypes(LtLight , LtDouble, LtLight , LtDouble), /* U+256A ╪ */
145​ makePackedLineTypes(LtDouble, LtLight , LtDouble, LtLight ), /* U+256B ╫ */
146​ makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtDouble), /* U+256C ╬ */
147​ 0, 0, 0, 0, 0, 0, 0, /* U+256D - U+2573 */
148​ makePackedLineTypes(LtNone , LtNone , LtNone , LtLight ), /* U+2574 ╴ */
149​ makePackedLineTypes(LtLight , LtNone , LtNone , LtNone ), /* U+2575 ╵ */
150​ makePackedLineTypes(LtNone , LtLight , LtNone , LtNone ), /* U+2576 ╶ */
151​ makePackedLineTypes(LtNone , LtNone , LtLight , LtNone ), /* U+2577 ╷ */
152​ makePackedLineTypes(LtNone , LtNone , LtNone , LtHeavy ), /* U+2578 ╸ */
153​ makePackedLineTypes(LtHeavy , LtNone , LtNone , LtNone ), /* U+2579 ╹ */
154​ makePackedLineTypes(LtNone , LtHeavy , LtNone , LtNone ), /* U+257A ╺ */
155​ makePackedLineTypes(LtNone , LtNone , LtHeavy , LtNone ), /* U+257B ╻ */
156​ makePackedLineTypes(LtNone , LtHeavy , LtNone , LtLight ), /* U+257C ╼ */
157​ makePackedLineTypes(LtLight , LtNone , LtHeavy , LtNone ), /* U+257D ╽ */
158​ makePackedLineTypes(LtNone , LtLight , LtNone , LtHeavy ), /* U+257E ╾ */
159​ makePackedLineTypes(LtHeavy , LtNone , LtLight , LtNone ), /* U+257F ╿ */
160​};
161​
162​
163​
164​// Bitwise rotate left
165​template <typename T>
166​inline static T rotl(T value, quint8 amount)
167​{
sandsmarkUnsubmitted
Done

rotl is a pretty normal acronym, but probably more readable if it's called rotateBitsLeft or something?

sandsmark: rotl is a pretty normal acronym, but probably more readable if it's called rotateBitsLeft or…
168​ static_assert (std::is_unsigned<T>(), "T must be unsigned type");
169​ assert(amount < sizeof(value) * 8);
170​ return value << amount | value >> (sizeof(value) * 8 - amount);
171​}
172​
fvogtUnsubmitted
Done

Stray ';' - results in compiler warning.

fvogt: Stray ';' - results in compiler warning.
173​inline static const QPen pen(const QPainter &paint, uint lineWidth)
174​{
175​ return QPen(paint.pen().brush(), lineWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
176​}
177​
178​
179​
180​static inline uint lineWidth(uint fontWidth, bool heavy, bool bold)
181​{
182​ static const qreal LightWidthToFontWidthRatio = 1.0 / 6.5;
183​ static const qreal HeavyHalfExtraToLightRatio = 1.0 / 3.0;
184​ static const qreal BoldCoefficient = 1.5;
185​
186​ // ▄▄▄▄▄▄▄ } heavyHalfExtraWidth ⎫
187​ // ██████████████ } lightWidth ⎬ heavyWidth
188​ // ▀▀▀▀▀▀▀ ⎭
189​ // light heavy
190​
191​ const qreal baseWidth = fontWidth * LightWidthToFontWidthRatio;
192​ const qreal boldCoeff = bold ? BoldCoefficient : 1.0;
193​ // Unless font size is too small, make bold lines at least 1px wider than regular lines
194​ const qreal minWidth = bold && fontWidth >= 7 ? baseWidth + 1.0 : 1.0;
fvogtUnsubmitted
Done

For fontWidth less than 8 this returns 1 for both bold and normal lines. Intentional?

IMO increasing the LightWidthToFontSizeRatio to 1/5 is acceptable.

fvogt: For `fontWidth` less than 8 this returns 1 for both bold and normal lines. Intentional? IMO…
mglbAuthorUnsubmitted
Done

It now returns 1 for normal and bold lines when the fontWidth is less than 7. It is just not possible to fit bold characters in such narrow space.

1/5 turned out to be too low. 1/6.5 works best. Minimum bold line width
is now set to normal line width + 1, so it is always bolder for character widths >= 7.

mglb: It now returns 1 for normal and bold lines when the fontWidth is less than 7. It is just not…
195​ const uint lightWidth = qRound(qMax(baseWidth * boldCoeff, minWidth));
196​ const uint heavyHalfExtraWidth = qRound(qMax(lightWidth * HeavyHalfExtraToLightRatio, 1.0));
197​
198​ return heavy ? lightWidth + 2 * heavyHalfExtraWidth : lightWidth;
199​}
200​
201​// Draws characters composed of straight solid lines
202​static bool drawBasicLineCharacter(QPainter& paint, int x, int y, int w, int h, uchar code,
203​ bool bold)
204​{
205​ quint8 packedLineTypes = code >= sizeof(PackedLineTypesLut) ? 0 : PackedLineTypesLut[code];
206​ if (packedLineTypes == 0) {
207​ return false;
208​ }
209​
210​ const uint lightLineWidth = lineWidth(w, false, bold);
211​ const uint heavyLineWidth = lineWidth(w, true, bold);
212​ // Distance from double line's parallel axis to each line's parallel axis
213​ const uint doubleLinesDistance = lightLineWidth;
214​
215​ const QPen lightPen = pen(paint, lightLineWidth);
216​ const QPen heavyPen = pen(paint, heavyLineWidth);
217​
218​ static constexpr const unsigned LinesNum = 4;
219​
220​ // Pixel aligned center point
221​ const QPointF center = {
222​ x + int(w/2) + 0.5 * (lightLineWidth % 2),
223​ y + int(h/2) + 0.5 * (lightLineWidth % 2),
224​ };
225​
226​ // Lines starting points, on the cell edges
227​ const QPointF origin[] = {
228​ QPointF(center.x(), y ),
229​ QPointF(x+w , center.y() ),
230​ QPointF(center.x(), y+h ),
231​ QPointF(x , center.y() ),
232​ };
233​ // Unit vectors with directions from center to the line's origin point
234​ static const QPointF dir[] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
235​
236​ const auto removeLineType = [&packedLineTypes](quint8 lineId)->void {
237​ lineId = LinesNum - 1 - lineId % LinesNum;
238​ packedLineTypes &= ~(3 << (2 * lineId));
239​ };
240​ const auto getLineType = [&packedLineTypes](quint8 lineId)->LineType {
241​ lineId = LinesNum - 1 - lineId % LinesNum;
242​ return LineType(packedLineTypes >> 2 * lineId & 3);
243​ };
244​
245​ QPainterPath ppl; // PainterPath for light lines (Painter Path Light)
246​ QPainterPath pph; // PainterPath for heavy lines (Painter Path Heavy)
247​ // Returns ppl or pph depending on line type
248​ const auto pp = [&](quint8 lineId) -> QPainterPath& {
249​ Q_ASSERT(getLineType(lineId) != LtNone);
sandsmarkUnsubmitted
Done

lightPath, heavyPath, maybe?

sandsmark: lightPath, heavyPath, maybe?
250​ return getLineType(lineId) == LtHeavy ? pph : ppl;
251​ };
252​
253​ // Process all single up-down/left-right lines for every character that has them. Doing it here
254​ // reduces amount of combinations below.
255​ // Fully draws: ╋ ╂ ┃ ┿ ┼ │ ━ ─
256​ for (unsigned iT = 0; iT < LinesNum/2; iT++) {
257​ unsigned iB = (iT + 2) % LinesNum;
258​ const bool isSingleLine = (getLineType(iT) == LtLight || getLineType(iT) == LtHeavy);
259​ if (isSingleLine && getLineType(iT) == getLineType(iB)) {
hindenburgUnsubmitted
Not Done

There's a krazy check that suggest this might be better using prefix due to efficient ( ie ++topIndex) - I haven't checked if this change would work here.

hindenburg: There's a krazy check that suggest this might be better using prefix due to efficient ( ie…
260​ pp(iT).moveTo(origin[iT]);
261​ pp(iT).lineTo(origin[iB]);
262​ removeLineType(iT);
263​ removeLineType(iB);
264​ }
265​ }
266​
267​ // Find normalized variant/rotation of the character and set line indices (iX) to draw valid
268​ // variant while pretending the base one is drawn. The normalized variant is defined as one with
269​ // largest packedLineTypes value.
270​ uint iT = 0; // top index
271​ quint8 normalizedPackedLineTypes = packedLineTypes;
272​ for (uint i = 0; i < LinesNum; i++) {
273​ const quint8 rplt = rotl(packedLineTypes, i * 2);
274​ if (rplt > normalizedPackedLineTypes) {
sandsmarkUnsubmitted
Done

topIndex?

sandsmark: topIndex?
275​ iT = i;
276​ normalizedPackedLineTypes = rplt;
277​ }
278​ }
279​ uint iR = (iT+1) % LinesNum; // right index
280​ uint iB = (iT+2) % LinesNum; // bottom index
281​ uint iL = (iT+3) % LinesNum; // left index
282​
283​ // Common paths
sandsmarkUnsubmitted
Done

not a fan of two-letter abbreviated variable names (against the Qt code style fwiw).

sandsmark: not a fan of two-letter abbreviated variable names (against the Qt code style fwiw).
284​ const auto drawDoubleUpRightShorterLine = [&](quint8 t, quint8 r) { // ╚
285​ ppl.moveTo(origin[t] + dir[r] * doubleLinesDistance);
286​ ppl.lineTo(center + (dir[r] + dir[t]) * doubleLinesDistance);
287​ ppl.lineTo(origin[r] + dir[t] * doubleLinesDistance);
288​ };
289​ const auto drawUpRight = [&](quint8 t, quint8 r) { // └┗
290​ pp(t).moveTo(origin[t]);
291​ pp(t).lineTo(center);
292​ pp(t).lineTo(origin[r]);
293​ };
294​
295​ switch (normalizedPackedLineTypes) {
296​ case makePackedLineTypes(LtHeavy , LtNone , LtLight , LtNone ): // ╿ ; ╼ ╽ ╾ ╊ ╇ ╉ ╈ ╀ ┾ ╁ ┽
297​ ppl.moveTo(origin[iB]);
298​ ppl.lineTo(center + dir[iT] * lightLineWidth / 2.0);
299​ Q_FALLTHROUGH();
300​ case makePackedLineTypes(LtHeavy , LtNone , LtNone , LtNone ): // ╹ ; ╺ ╻ ╸ ┻ ┣ ┳ ┫ ┸ ┝ ┰ ┥
301​ case makePackedLineTypes(LtLight , LtNone , LtNone , LtNone ): // ╵ ; ╶ ╷ ╴ ┷ ┠ ┯ ┨ ┴ ├ ┬ ┤
302​ pp(iT).moveTo(origin[iT]);
303​ pp(iT).lineTo(center);
304​ break;
305​
306​ case makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtLight ): // ╄ ; ╃ ╆ ╅
307​ drawUpRight(iB, iL);
308​ Q_FALLTHROUGH();
309​ case makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtNone ): // ┗ ; ┛ ┏ ┓
310​ case makePackedLineTypes(LtLight , LtLight , LtNone , LtNone ): // └ ; ┘ ┌ ┐
311​ drawUpRight(iT, iR);
312​ break;
313​
314​ case makePackedLineTypes(LtHeavy , LtLight , LtNone , LtNone ): // ┖ ; ┙ ┍ ┒
315​ qSwap(iL, iR);
316​ Q_FALLTHROUGH();
317​ case makePackedLineTypes(LtHeavy , LtNone , LtNone , LtLight ): // ┚ ; ┕ ┎ ┑
318​ ppl.moveTo(origin[iL]);
319​ ppl.lineTo(center);
320​ pph.moveTo(origin[iT]);
321​ pph.lineTo(center + dir[iB] * lightLineWidth / 2.0);
322​ break;
323​
324​ case makePackedLineTypes(LtLight , LtDouble, LtNone , LtNone ): // ╘ ; ╜ ╓ ╕
325​ qSwap(iL, iR);
326​ Q_FALLTHROUGH();
327​ case makePackedLineTypes(LtLight , LtNone , LtNone , LtDouble): // ╛ ; ╙ ╒ ╖
328​ ppl.moveTo(origin[iT]);
329​ ppl.lineTo(center + dir[iB] * doubleLinesDistance);
330​ ppl.lineTo(origin[iL] + dir[iB] * doubleLinesDistance);
331​ ppl.moveTo(origin[iL] - dir[iB] * doubleLinesDistance);
332​ ppl.lineTo(center - dir[iB] * doubleLinesDistance);
333​ break;
334​
335​ case makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtNone ): // ┡ ; ┹ ┪ ┲
336​ qSwap(iL, iB);
337​ qSwap(iR, iT);
338​ Q_FALLTHROUGH();
339​ case makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtLight ): // ┺ ; ┩ ┢ ┱
340​ drawUpRight(iT, iR);
341​ ppl.moveTo(origin[iL]);
342​ ppl.lineTo(center);
343​ break;
344​
345​ case makePackedLineTypes(LtHeavy , LtLight , LtLight , LtNone ): // ┞ ; ┵ ┧ ┮
346​ qSwap(iL, iR);
347​ Q_FALLTHROUGH();
348​ case makePackedLineTypes(LtHeavy , LtNone , LtLight , LtLight ): // ┦ ; ┶ ┟ ┭
349​ pph.moveTo(origin[iT]);
350​ pph.lineTo(center + dir[iB] * lightLineWidth / 2.0);
351​ drawUpRight(iB, iL);
352​ break;
353​
354​ case makePackedLineTypes(LtLight , LtDouble, LtNone , LtDouble): // ╧ ; ╟ ╢ ╤
355​ ppl.moveTo(origin[iT]);
356​ ppl.lineTo(center - dir[iB] * doubleLinesDistance);
357​ qSwap(iL, iB);
358​ qSwap(iR, iT);
359​ Q_FALLTHROUGH();
360​ case makePackedLineTypes(LtDouble, LtNone , LtDouble, LtNone ): // ║ ; ╫ ═ ╪
361​ ppl.moveTo(origin[iT] + dir[iL] * doubleLinesDistance);
362​ ppl.lineTo(origin[iB] + dir[iL] * doubleLinesDistance);
363​ ppl.moveTo(origin[iT] + dir[iR] * doubleLinesDistance);
364​ ppl.lineTo(origin[iB] + dir[iR] * doubleLinesDistance);
365​ break;
366​
367​ case makePackedLineTypes(LtDouble, LtNone , LtNone , LtNone ): // ╨ ; ╞ ╥ ╡
368​ ppl.moveTo(origin[iT] + dir[iL] * doubleLinesDistance);
369​ ppl.lineTo(center + dir[iL] * doubleLinesDistance);
370​ ppl.moveTo(origin[iT] + dir[iR] * doubleLinesDistance);
371​ ppl.lineTo(center + dir[iR] * doubleLinesDistance);
372​ break;
373​
374​ case makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtDouble): // ╬
375​ drawDoubleUpRightShorterLine(iT, iR);
376​ drawDoubleUpRightShorterLine(iB, iR);
377​ drawDoubleUpRightShorterLine(iT, iL);
378​ drawDoubleUpRightShorterLine(iB, iL);
379​ break;
380​
381​ case makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtNone ): // ╠ ; ╩ ╣ ╦
382​ ppl.moveTo(origin[iT] + dir[iL] * doubleLinesDistance);
383​ ppl.lineTo(origin[iB] + dir[iL] * doubleLinesDistance);
384​ drawDoubleUpRightShorterLine(iT, iR);
385​ drawDoubleUpRightShorterLine(iB, iR);
386​ break;
387​
388​ case makePackedLineTypes(LtDouble, LtDouble, LtNone , LtNone ): // ╚ ; ╝ ╔ ╗
389​ ppl.moveTo(origin[iT] + dir[iL] * doubleLinesDistance);
390​ ppl.lineTo(center + (dir[iL] + dir[iB]) * doubleLinesDistance);
391​ ppl.lineTo(origin[iR] + dir[iB] * doubleLinesDistance);
392​ drawDoubleUpRightShorterLine(iT, iR);
393​ break;
394​ }
395​
396​ // Draw paths
397​ if (!ppl.isEmpty()) {
398​ paint.strokePath(ppl, lightPen);
399​ }
400​ if (!pph.isEmpty()) {
401​ paint.strokePath(pph, heavyPen);
402​ }
403​
404​ return true;
405​}
406​
407​static inline bool drawDashedLineCharacter(QPainter &paint, int x, int y, int w, int h, uchar code,
408​ bool bold)
409​{
410​ if (!((0x04 <= code && code <= 0x0B) || (0x4C <= code && code <= 0x4F))) {
411​ return false;
412​ }
413​
414​ const uint lightLineWidth = lineWidth(w, false, bold);
415​ const uint heavyLineWidth = lineWidth(w, true, bold);
416​
417​ const auto lightPen = pen(paint, lightLineWidth);
418​ const auto heavyPen = pen(paint, heavyLineWidth);
419​
420​ // Center point
421​ const QPointF c = {
422​ x + w/2.0,
423​ y + h/2.0,
424​ };
425​ // Pixel aligned center point
426​ const QPointF pc = {
427​ int(c.x()) + 0.5 * (lightLineWidth%2),
428​ int(c.y()) + 0.5 * (lightLineWidth%2),
429​ };
430​
431​ const qreal halfGapH = qMax(w / 20.0, 0.5);
432​ const qreal halfGapV = qMax(h / 26.0, 0.5);
433​ // For some reason vertical double dash has bigger gap
434​ const qreal halfGapDDV = qMax(h / 14.0, 0.5);
435​
436​ static const int LinesNumMax = 4;
437​
438​ enum Orientation {Horizontal, Vertical};
439​ struct {
440​ int linesNum;
441​ Orientation orientation;
442​ qreal halfGap;
443​ QPen pen;
444​ } lp;
445​
446​ switch (code) {
447​ case 0x4C: lp = {2, Horizontal, halfGapH , lightPen}; break;
448​ case 0x4D: lp = {2, Horizontal, halfGapH , heavyPen}; break;
449​ case 0x4E: lp = {2, Vertical , halfGapDDV, lightPen}; break;
450​ case 0x4F: lp = {2, Vertical , halfGapDDV, heavyPen}; break;
sandsmarkUnsubmitted
Done

maybe a comment to show which is which? in case of future debugging.

sandsmark: maybe a comment to show which is which? in case of future debugging.
mglbAuthorUnsubmitted
Not Done

I've added comments with respective characters and swapped 3rd and 4th field, so the character name/description is almost directly seen in first three fields

mglb: I've added comments with respective characters and swapped 3rd and 4th field, so the character…
451​ case 0x04: lp = {3, Horizontal, halfGapH , lightPen}; break;
452​ case 0x05: lp = {3, Horizontal, halfGapH , heavyPen}; break;
453​ case 0x06: lp = {3, Vertical , halfGapV , lightPen}; break;
454​ case 0x07: lp = {3, Vertical , halfGapV , heavyPen}; break;
455​ case 0x08: lp = {4, Horizontal, halfGapH , lightPen}; break;
456​ case 0x09: lp = {4, Horizontal, halfGapH , heavyPen}; break;
457​ case 0x0A: lp = {4, Vertical , halfGapV , lightPen}; break;
458​ case 0x0B: lp = {4, Vertical , halfGapV , heavyPen}; break;
459​ }
460​
461​ Q_ASSERT(lp.linesNum <= LinesNumMax);
462​ const int size = (lp.orientation == Horizontal ? w : h);
463​ const int off = (lp.orientation == Horizontal ? x : y);
464​ QLineF lines[LinesNumMax];
465​
466​ for (int i = 0; i < lp.linesNum; i++) {
467​ const qreal start = off + qreal(size * (i )) / lp.linesNum;
468​ const qreal end = off + qreal(size * (i+1)) / lp.linesNum;
469​ if (lp.orientation == Horizontal) {
470​ lines[i] = QLineF{start + lp.halfGap, pc.y(), end - lp.halfGap, pc.y()};
471​ } else {
472​ lines[i] = QLineF{pc.x(), start + lp.halfGap, pc.x(), end - lp.halfGap};
473​ }
474​ }
475​
476​ const auto origPen = paint.pen();
477​
478​ paint.setPen(lp.pen);
479​ paint.drawLines(lines, lp.linesNum);
480​
481​ paint.setPen(origPen);
482​ return true;
483​}
484​
485​static inline bool drawRoundedCornerLineCharacter(QPainter &paint, int x, int y, int w, int h,
486​ uchar code, bool bold)
487​{
488​ if (!(0x6D <= code && code <= 0x70)) {
489​ return false;
490​ }
491​
492​ const uint lightLineWidth = lineWidth(w, false, bold);
493​ const auto lightPen = pen(paint, lightLineWidth);
494​
495​ // Center point
496​ const QPointF c = {
497​ x + w/2.0,
498​ y + h/2.0,
499​ };
500​ // Pixel aligned center point
501​ const QPointF pc = {
502​ int(c.x()) + 0.5 * (lightLineWidth%2),
503​ int(c.y()) + 0.5 * (lightLineWidth%2),
504​ };
505​
506​ const int r = w * 3 / 8;
507​ const int d = 2 * r;
508​
509​ QPainterPath pp;
510​
511​ // lineTo() between moveTo and arcTo is redundant - arcTo() draws line
512​ // to the arc's starting point
513​ switch (code) {
514​ case 0x6D: // BOX DRAWINGS LIGHT ARC DOWN AND RIGHT
515​ pp.moveTo(pc.x(), y + h);
516​ pp.arcTo(pc.x(), pc.y(), d, d, 180, -90);
517​ pp.lineTo(x + w, pc.y());
518​ break;
519​ case 0x6E: // BOX DRAWINGS LIGHT ARC DOWN AND LEFT
520​ pp.moveTo(pc.x(), y + h);
521​ pp.arcTo(pc.x() - d, pc.y(), d, d, 0, 90);
522​ pp.lineTo(x, pc.y());
523​ break;
524​ case 0x6F: // BOX DRAWINGS LIGHT ARC UP AND LEFT
525​ pp.moveTo(pc.x(), y);
526​ pp.arcTo(pc.x() - d, pc.y() - d, d, d, 0, -90);
527​ pp.lineTo(x, pc.y());
528​ break;
529​ case 0x70: // BOX DRAWINGS LIGHT ARC UP AND RIGHT
530​ pp.moveTo(pc.x(), y);
531​ pp.arcTo(pc.x(), pc.y() - d, d, d, 180, 90);
532​ pp.lineTo(x + w, pc.y());
533​ break;
534​ }
535​ paint.strokePath(pp, lightPen);
536​
537​ return true;
538​}
539​
540​static inline bool drawDiagonalLineCharacter(QPainter &paint, int x, int y, int w, int h,
541​ uchar code, bool bold)
542​{
543​ if (!(0x71 <= code && code <= 0x73)) {
544​ return false;
545​ }
546​
547​ const uint lightLineWidth = lineWidth(w, false, bold);
548​ const auto lightPen = pen(paint, lightLineWidth);
549​
550​ const QLineF lines[] = {
551​ QLineF(x+w, y, x , y+h), // '/'
552​ QLineF(x , y, x+w, y+h), // '\'
553​ };
554​
555​ const auto origPen = paint.pen();
556​
557​ paint.setPen(lightPen);
558​ switch (code) {
559​ case 0x71: // BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT
560​ paint.drawLine(lines[0]);
561​ break;
562​ case 0x72: // BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT
563​ paint.drawLine(lines[1]);
564​ break;
565​ case 0x73: // BOX DRAWINGS LIGHT DIAGONAL CROSS
566​ paint.drawLines(lines, 2);
567​ break;
568​ }
569​
570​ paint.setPen(origPen);
571​ return true;
572​}
573​
574​static inline bool drawBlockCharacter(QPainter &paint, int x, int y, int w, int h, uchar code,
575​ bool bold)
576​{
577​ Q_UNUSED(bold);
578​
579​ const QColor color = paint.pen().color();
580​
581​ // Center point
582​ const QPointF c = {
583​ x + w/2.0,
584​ y + h/2.0,
585​ };
586​
587​ // Default rect fills entire cell
588​ QRectF rect(x, y, w, h);
589​
590​ // LOWER ONE EIGHTH BLOCK to LEFT ONE EIGHTH BLOCK
591​ if (code >= 0x81 && code <= 0x8f) {
592​ if (code < 0x88) { // Horizontal
593​ const qreal height = h * (0x88 - code) / 8.0;
594​ rect.setY(y + height);
595​ rect.setHeight(h - height);
596​ } else if (code > 0x88) { // Vertical
597​ const qreal width = w * (0x90 - code) / 8.0;
598​ rect.setWidth(width);
599​ }
600​ paint.fillRect(rect, color);
601​
602​ return true;
603​ }
604​
605​ // Combinations of quarter squares
606​ // LEFT ONE EIGHTH BLOCK to QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT
607​ if (code >= 0x96 && code <= 0x9F) {
608​ const QRectF upperLeft (x , y , w/2.0, h/2.0);
609​ const QRectF upperRight(c.x(), y , w/2.0, h/2.0);
610​ const QRectF lowerLeft (x , c.y(), w/2.0, h/2.0);
611​ const QRectF lowerRight(c.x(), c.y(), w/2.0, h/2.0);
612​
613​ QPainterPath path;
614​
615​ switch (code) {
616​ case 0x96:
617​ path.addRect(lowerLeft);
618​ break;
619​ case 0x97:
620​ path.addRect(lowerRight);
621​ break;
622​ case 0x98:
623​ path.addRect(upperLeft);
624​ break;
625​ case 0x99:
626​ path.addRect(upperLeft);
627​ path.addRect(lowerLeft);
628​ path.addRect(lowerRight);
629​ break;
630​ case 0x9a:
631​ path.addRect(upperLeft);
632​ path.addRect(lowerRight);
633​ break;
634​ case 0x9b:
635​ path.addRect(upperLeft);
636​ path.addRect(upperRight);
637​ path.addRect(lowerLeft);
638​ break;
639​ case 0x9c:
640​ path.addRect(upperLeft);
641​ path.addRect(upperRight);
642​ path.addRect(lowerRight);
643​ break;
644​ case 0x9d:
645​ path.addRect(upperRight);
646​ break;
647​ case 0x9e:
648​ path.addRect(upperRight);
649​ path.addRect(lowerLeft);
650​ break;
651​ case 0x9f:
652​ path.addRect(upperRight);
653​ path.addRect(lowerLeft);
654​ path.addRect(lowerRight);
655​ break;
656​ }
657​ paint.fillPath(path, color);
658​
659​ return true;
660​ }
661​
662​ QBrush lightShade, mediumShade, darkShade;
663​ if (paint.testRenderHint(QPainter::Antialiasing)) {
664​ lightShade = QColor(color.red(), color.green(), color.blue(), 64);
665​ mediumShade = QColor(color.red(), color.green(), color.blue(), 128);
666​ darkShade = QColor(color.red(), color.green(), color.blue(), 192);
667​ } else {
668​ lightShade = QBrush(color, Qt::Dense6Pattern);
669​ mediumShade = QBrush(color, Qt::Dense4Pattern);
670​ darkShade = QBrush(color, Qt::Dense2Pattern);
671​ }
672​ // And the random stuff
673​ switch (code) {
674​ case 0x80: // Top half block
675​ rect.setHeight(h/2.0);
676​ paint.fillRect(rect, color);
677​ return true;
678​ case 0x90: // Right half block
679​ rect.moveLeft(c.x());
680​ paint.fillRect(rect, color);
681​ return true;
682​ case 0x94: // Top one eighth block
683​ rect.setHeight(h/8.0);
684​ paint.fillRect(rect, color);
685​ return true;
686​ case 0x95: { // Right one eighth block
687​ const qreal width = 7 * w / 8.0;
688​ rect.moveLeft(x + width);
689​ paint.fillRect(rect, color);
690​ return true;
691​ }
692​ case 0x91: // Light shade
693​ paint.fillRect(rect, lightShade);
694​ return true;
695​ case 0x92: // Medium shade
696​ paint.fillRect(rect, mediumShade);
697​ return true;
698​ case 0x93: // Dark shade
699​ paint.fillRect(rect, darkShade);
700​ return true;
701​
702​ default:
703​ return false;
704​ }
705​}
706​
707​void draw(QPainter &paint, const QRect &cellRect, const QChar &chr, bool bold)
708​{
709​ static const ushort FirstBoxDrawingCharacterCodePoint = 0x2500;
710​ const uchar code = chr.unicode() - FirstBoxDrawingCharacterCodePoint;
711​
712​ int x = cellRect.x();
713​ int y = cellRect.y();
714​ int w = cellRect.width();
715​ int h = cellRect.height();
716​
717​ // Each function below returns true when it has drawn the character, false otherwise.
718​ drawBasicLineCharacter(paint, x, y, w, h, code, bold)
719​ || drawDashedLineCharacter(paint, x, y, w, h, code, bold)
720​ || drawRoundedCornerLineCharacter(paint, x, y, w, h, code, bold)
721​ || drawDiagonalLineCharacter(paint, x, y, w, h, code, bold)
722​ || drawBlockCharacter(paint, x, y, w, h, code, bold);
723​}
724​
725​} // namespace LineBlockCharacters
726​} // namespace Konsole