Differential D18735 Diff 51559 src/LineBlockCharacters.cpp

Changeset View

Standalone View

src/LineBlockCharacters.cpp

This file was added.

1		/*
2		This file is part of Konsole, a terminal emulator for KDE.
3
4		Copyright 2018-2019 by Mariusz Glebocki <mglb@arccos-1.net>
5		Copyright 2018 by Martin T. H. Sandsmark <martin.sandsmark@kde.org>
6		Copyright 2015-2018 by Kurt Hindenburg <kurt.hindenburg@gmail.com>
7		Copyright 2005 by Maksim Orlovich
8
9		This program is free software; you can redistribute it and/or modify
10		it under the terms of the GNU General Public License as published by
11		the Free Software Foundation; either version 2 of the License, or
12		(at your option) any later version.
13
14		This program is distributed in the hope that it will be useful,
15		but WITHOUT ANY WARRANTY; without even the implied warranty of
16		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		GNU General Public License for more details.
18
19		You should have received a copy of the GNU General Public License
20		along with this program; if not, write to the Free Software
21		Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22		02110-1301 USA.
23		*/
24
25		// Own
26		#include "LineBlockCharacters.h"
27
28		// Qt
29		#include <QPainter>
30
31		namespace Konsole {
32		namespace LineBlockCharacters {
33
34		enum LineType {
35		LtNone = 0,
36		LtDouble = 1,
37		LtLight = 2,
38		LtHeavy = 3,
39		};
40
41		// PackedLineTypes is an 8-bit number representing types of 4 line character's lines. Each line is
42		// represented by 2 bits. Lines order, starting from MSB: top, right, bottom, left.
43		static inline constexpr quint8 makePackedLineTypes(LineType top, LineType right, LineType bottom, LineType left)
44		{
45		return (int(top) & 3) << 6 \| (int(right) & 3) << 4 \| (int(bottom) & 3) << 2 \| (int(left) & 3);
46		}
47
48		static constexpr const quint8 PackedLineTypesLut[] = {
49		// top right bottom left
50		makePackedLineTypes(LtNone , LtLight , LtNone , LtLight ), /* U+2500 ─ */
51		makePackedLineTypes(LtNone , LtHeavy , LtNone , LtHeavy ), /* U+2501 ━ */
52		makePackedLineTypes(LtLight , LtNone , LtLight , LtNone ), /* U+2502 │ */
53		makePackedLineTypes(LtHeavy , LtNone , LtHeavy , LtNone ), /* U+2503 ┃ */
54		0, 0, 0, 0, 0, 0, 0, 0, /* U+2504-0x250b */
55		makePackedLineTypes(LtNone , LtLight , LtLight , LtNone ), /* U+250C ┌ */
56		makePackedLineTypes(LtNone , LtHeavy , LtLight , LtNone ), /* U+250D ┍ */
57		makePackedLineTypes(LtNone , LtLight , LtHeavy , LtNone ), /* U+250E ┎ */
58		makePackedLineTypes(LtNone , LtHeavy , LtHeavy , LtNone ), /* U+250F ┏ */
59		makePackedLineTypes(LtNone , LtNone , LtLight , LtLight ), /* U+2510 ┐ */
60		makePackedLineTypes(LtNone , LtNone , LtLight , LtHeavy ), /* U+2511 ┑ */
61		makePackedLineTypes(LtNone , LtNone , LtHeavy , LtLight ), /* U+2512 ┒ */
62		makePackedLineTypes(LtNone , LtNone , LtHeavy , LtHeavy ), /* U+2513 ┓ */
63		makePackedLineTypes(LtLight , LtLight , LtNone , LtNone ), /* U+2514 └ */
64		makePackedLineTypes(LtLight , LtHeavy , LtNone , LtNone ), /* U+2515 ┕ */
65		makePackedLineTypes(LtHeavy , LtLight , LtNone , LtNone ), /* U+2516 ┖ */
66		makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtNone ), /* U+2517 ┗ */
67		makePackedLineTypes(LtLight , LtNone , LtNone , LtLight ), /* U+2518 ┘ */
68		makePackedLineTypes(LtLight , LtNone , LtNone , LtHeavy ), /* U+2519 ┙ */
69		makePackedLineTypes(LtHeavy , LtNone , LtNone , LtLight ), /* U+251A ┚ */
70		makePackedLineTypes(LtHeavy , LtNone , LtNone , LtHeavy ), /* U+251B ┛ */
71		makePackedLineTypes(LtLight , LtLight , LtLight , LtNone ), /* U+251C ├ */
72		makePackedLineTypes(LtLight , LtHeavy , LtLight , LtNone ), /* U+251D ┝ */
73		makePackedLineTypes(LtHeavy , LtLight , LtLight , LtNone ), /* U+251E ┞ */
74		makePackedLineTypes(LtLight , LtLight , LtHeavy , LtNone ), /* U+251F ┟ */
75		makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtNone ), /* U+2520 ┠ */
76		makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtNone ), /* U+2521 ┡ */
77		makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtNone ), /* U+2522 ┢ */
78		makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtNone ), /* U+2523 ┣ */
79		makePackedLineTypes(LtLight , LtNone , LtLight , LtLight ), /* U+2524 ┤ */
80		makePackedLineTypes(LtLight , LtNone , LtLight , LtHeavy ), /* U+2525 ┥ */
81		makePackedLineTypes(LtHeavy , LtNone , LtLight , LtLight ), /* U+2526 ┦ */
82		makePackedLineTypes(LtLight , LtNone , LtHeavy , LtLight ), /* U+2527 ┧ */
83		makePackedLineTypes(LtHeavy , LtNone , LtHeavy , LtLight ), /* U+2528 ┨ */
84		makePackedLineTypes(LtHeavy , LtNone , LtLight , LtHeavy ), /* U+2529 ┩ */
85		makePackedLineTypes(LtLight , LtNone , LtHeavy , LtHeavy ), /* U+252A ┪ */
86		makePackedLineTypes(LtHeavy , LtNone , LtHeavy , LtHeavy ), /* U+252B ┫ */
87		makePackedLineTypes(LtNone , LtLight , LtLight , LtLight ), /* U+252C ┬ */
88		makePackedLineTypes(LtNone , LtLight , LtLight , LtHeavy ), /* U+252D ┭ */
89		makePackedLineTypes(LtNone , LtHeavy , LtLight , LtLight ), /* U+252E ┮ */
90		makePackedLineTypes(LtNone , LtHeavy , LtLight , LtHeavy ), /* U+252F ┯ */
91		makePackedLineTypes(LtNone , LtLight , LtHeavy , LtLight ), /* U+2530 ┰ */
92		makePackedLineTypes(LtNone , LtLight , LtHeavy , LtHeavy ), /* U+2531 ┱ */
93		makePackedLineTypes(LtNone , LtHeavy , LtHeavy , LtLight ), /* U+2532 ┲ */
94		makePackedLineTypes(LtNone , LtHeavy , LtHeavy , LtHeavy ), /* U+2533 ┳ */
95		makePackedLineTypes(LtLight , LtLight , LtNone , LtLight ), /* U+2534 ┴ */
96		makePackedLineTypes(LtLight , LtLight , LtNone , LtHeavy ), /* U+2535 ┵ */
97		makePackedLineTypes(LtLight , LtHeavy , LtNone , LtLight ), /* U+2536 ┶ */
98		makePackedLineTypes(LtLight , LtHeavy , LtNone , LtHeavy ), /* U+2537 ┷ */
99		makePackedLineTypes(LtHeavy , LtLight , LtNone , LtLight ), /* U+2538 ┸ */
100		makePackedLineTypes(LtHeavy , LtLight , LtNone , LtHeavy ), /* U+2539 ┹ */
101		makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtLight ), /* U+253A ┺ */
102		makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtHeavy ), /* U+253B ┻ */
103		makePackedLineTypes(LtLight , LtLight , LtLight , LtLight ), /* U+253C ┼ */
104		makePackedLineTypes(LtLight , LtLight , LtLight , LtHeavy ), /* U+253D ┽ */
105		makePackedLineTypes(LtLight , LtHeavy , LtLight , LtLight ), /* U+253E ┾ */
106		makePackedLineTypes(LtLight , LtHeavy , LtLight , LtHeavy ), /* U+253F ┿ */
107		makePackedLineTypes(LtHeavy , LtLight , LtLight , LtLight ), /* U+2540 ╀ */
108		makePackedLineTypes(LtLight , LtLight , LtHeavy , LtLight ), /* U+2541 ╁ */
109		makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtLight ), /* U+2542 ╂ */
110		makePackedLineTypes(LtHeavy , LtLight , LtLight , LtHeavy ), /* U+2543 ╃ */
111		makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtLight ), /* U+2544 ╄ */
112		makePackedLineTypes(LtLight , LtLight , LtHeavy , LtHeavy ), /* U+2545 ╅ */
113		makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtLight ), /* U+2546 ╆ */
114		makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtHeavy ), /* U+2547 ╇ */
115		makePackedLineTypes(LtLight , LtHeavy , LtHeavy , LtHeavy ), /* U+2548 ╈ */
116		makePackedLineTypes(LtHeavy , LtLight , LtHeavy , LtHeavy ), /* U+2549 ╉ */
117		makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtLight ), /* U+254A ╊ */
118		makePackedLineTypes(LtHeavy , LtHeavy , LtHeavy , LtHeavy ), /* U+254B ╋ */
119		0, 0, 0, 0, /* U+254C - U+254F */
120		makePackedLineTypes(LtNone , LtDouble, LtNone , LtDouble), /* U+2550 ═ */
121		makePackedLineTypes(LtDouble, LtNone , LtDouble, LtNone ), /* U+2551 ║ */
122		makePackedLineTypes(LtNone , LtDouble, LtLight , LtNone ), /* U+2552 ╒ */
123		makePackedLineTypes(LtNone , LtLight , LtDouble, LtNone ), /* U+2553 ╓ */
124		makePackedLineTypes(LtNone , LtDouble, LtDouble, LtNone ), /* U+2554 ╔ */
125		makePackedLineTypes(LtNone , LtNone , LtLight , LtDouble), /* U+2555 ╕ */
126		makePackedLineTypes(LtNone , LtNone , LtDouble, LtLight ), /* U+2556 ╖ */
127		makePackedLineTypes(LtNone , LtNone , LtDouble, LtDouble), /* U+2557 ╗ */
128		makePackedLineTypes(LtLight , LtDouble, LtNone , LtNone ), /* U+2558 ╘ */
129		makePackedLineTypes(LtDouble, LtLight , LtNone , LtNone ), /* U+2559 ╙ */
130		makePackedLineTypes(LtDouble, LtDouble, LtNone , LtNone ), /* U+255A ╚ */
131		makePackedLineTypes(LtLight , LtNone , LtNone , LtDouble), /* U+255B ╛ */
132		makePackedLineTypes(LtDouble, LtNone , LtNone , LtLight ), /* U+255C ╜ */
133		makePackedLineTypes(LtDouble, LtNone , LtNone , LtDouble), /* U+255D ╝ */
134		makePackedLineTypes(LtLight , LtDouble, LtLight , LtNone ), /* U+255E ╞ */
135		makePackedLineTypes(LtDouble, LtLight , LtDouble, LtNone ), /* U+255F ╟ */
136		makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtNone ), /* U+2560 ╠ */
137		makePackedLineTypes(LtLight , LtNone , LtLight , LtDouble), /* U+2561 ╡ */
138		makePackedLineTypes(LtDouble, LtNone , LtDouble, LtLight ), /* U+2562 ╢ */
139		makePackedLineTypes(LtDouble, LtNone , LtDouble, LtDouble), /* U+2563 ╣ */
140		makePackedLineTypes(LtNone , LtDouble, LtLight , LtDouble), /* U+2564 ╤ */
141		makePackedLineTypes(LtNone , LtLight , LtDouble, LtLight ), /* U+2565 ╥ */
142		makePackedLineTypes(LtNone , LtDouble, LtDouble, LtDouble), /* U+2566 ╦ */
143		makePackedLineTypes(LtLight , LtDouble, LtNone , LtDouble), /* U+2567 ╧ */
144		makePackedLineTypes(LtDouble, LtLight , LtNone , LtLight ), /* U+2568 ╨ */
145		makePackedLineTypes(LtDouble, LtDouble, LtNone , LtDouble), /* U+2569 ╩ */
146		makePackedLineTypes(LtLight , LtDouble, LtLight , LtDouble), /* U+256A ╪ */
147		makePackedLineTypes(LtDouble, LtLight , LtDouble, LtLight ), /* U+256B ╫ */
148		makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtDouble), /* U+256C ╬ */
149		0, 0, 0, 0, 0, 0, 0, /* U+256D - U+2573 */
150		makePackedLineTypes(LtNone , LtNone , LtNone , LtLight ), /* U+2574 ╴ */
151		makePackedLineTypes(LtLight , LtNone , LtNone , LtNone ), /* U+2575 ╵ */
152		makePackedLineTypes(LtNone , LtLight , LtNone , LtNone ), /* U+2576 ╶ */
153		makePackedLineTypes(LtNone , LtNone , LtLight , LtNone ), /* U+2577 ╷ */
154		makePackedLineTypes(LtNone , LtNone , LtNone , LtHeavy ), /* U+2578 ╸ */
155		makePackedLineTypes(LtHeavy , LtNone , LtNone , LtNone ), /* U+2579 ╹ */
156		makePackedLineTypes(LtNone , LtHeavy , LtNone , LtNone ), /* U+257A ╺ */
157		makePackedLineTypes(LtNone , LtNone , LtHeavy , LtNone ), /* U+257B ╻ */
158		makePackedLineTypes(LtNone , LtHeavy , LtNone , LtLight ), /* U+257C ╼ */
159		makePackedLineTypes(LtLight , LtNone , LtHeavy , LtNone ), /* U+257D ╽ */
160		makePackedLineTypes(LtNone , LtLight , LtNone , LtHeavy ), /* U+257E ╾ */
161		makePackedLineTypes(LtHeavy , LtNone , LtLight , LtNone ), /* U+257F ╿ */
162		};
163
164
165
166		// Bitwise rotate left
167		template <typename T>
	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		inline static T rotateBitsLeft(T value, quint8 amount)
169		{
170		static_assert (std::is_unsigned<T>(), "T must be unsigned type");
171		assert(amount < sizeof(value) * 8);
172		return value << amount \| value >> (sizeof(value) * 8 - amount);
	fvogtUnsubmitted Done Stray ';' - results in compiler warning. fvogt: Stray ';' - results in compiler warning.
173		}
174
175		inline static const QPen pen(const QPainter &paint, uint lineWidth)
176		{
177		return QPen(paint.pen().brush(), lineWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
178		}
179
180
181
182		static inline uint lineWidth(uint fontWidth, bool heavy, bool bold)
183		{
184		static const qreal LightWidthToFontWidthRatio = 1.0 / 6.5;
185		static const qreal HeavyHalfExtraToLightRatio = 1.0 / 3.0;
186		static const qreal BoldCoefficient = 1.5;
187
188		// ▄▄▄▄▄▄▄ } heavyHalfExtraWidth ⎫
189		// ██████████████ } lightWidth ⎬ heavyWidth
190		// ▀▀▀▀▀▀▀ ⎭
191		// light heavy
192
193		const qreal baseWidth = fontWidth * LightWidthToFontWidthRatio;
194		const qreal boldCoeff = bold ? BoldCoefficient : 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		// Unless font size is too small, make bold lines at least 1px wider than regular lines
196		const qreal minWidth = bold && fontWidth >= 7 ? baseWidth + 1.0 : 1.0;
197		const uint lightWidth = qRound(qMax(baseWidth * boldCoeff, minWidth));
198		const uint heavyHalfExtraWidth = qRound(qMax(lightWidth * HeavyHalfExtraToLightRatio, 1.0));
199
200		return heavy ? lightWidth + 2 * heavyHalfExtraWidth : lightWidth;
201		}
202
203		// Draws characters composed of straight solid lines
204		static bool drawBasicLineCharacter(QPainter& paint, int x, int y, int w, int h, uchar code,
205		bool bold)
206		{
207		quint8 packedLineTypes = code >= sizeof(PackedLineTypesLut) ? 0 : PackedLineTypesLut[code];
208		if (packedLineTypes == 0) {
209		return false;
210		}
211
212		const uint lightLineWidth = lineWidth(w, false, bold);
213		const uint heavyLineWidth = lineWidth(w, true, bold);
214		// Distance from double line's parallel axis to each line's parallel axis
215		const uint doubleLinesDistance = lightLineWidth;
216
217		const QPen lightPen = pen(paint, lightLineWidth);
218		const QPen heavyPen = pen(paint, heavyLineWidth);
219
220		static constexpr const unsigned LinesNum = 4;
221
222		// Pixel aligned center point
223		const QPointF center = {
224		x + int(w/2) + 0.5 * (lightLineWidth % 2),
225		y + int(h/2) + 0.5 * (lightLineWidth % 2),
226		};
227
228		// Lines starting points, on the cell edges
229		const QPointF origin[] = {
230		QPointF(center.x(), y ),
231		QPointF(x+w , center.y() ),
232		QPointF(center.x(), y+h ),
233		QPointF(x , center.y() ),
234		};
235		// Unit vectors with directions from center to the line's origin point
236		static const QPointF dir[] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
237
238		const auto removeLineType = [&packedLineTypes](quint8 lineId)->void {
239		lineId = LinesNum - 1 - lineId % LinesNum;
240		packedLineTypes &= ~(3 << (2 * lineId));
241		};
242		const auto getLineType = [&packedLineTypes](quint8 lineId)->LineType {
243		lineId = LinesNum - 1 - lineId % LinesNum;
244		return LineType(packedLineTypes >> 2 * lineId & 3);
245		};
246
247		QPainterPath lightPath; // PainterPath for light lines (Painter Path Light)
248		QPainterPath heavyPath; // PainterPath for heavy lines (Painter Path Heavy)
249		// Returns ppl or pph depending on line type
	sandsmarkUnsubmitted Done lightPath, heavyPath, maybe? sandsmark: lightPath, heavyPath, maybe?
250		const auto pathForLine = [&](quint8 lineId) -> QPainterPath& {
251		Q_ASSERT(getLineType(lineId) != LtNone);
252		return getLineType(lineId) == LtHeavy ? heavyPath : lightPath;
253		};
254
255		// Process all single up-down/left-right lines for every character that has them. Doing it here
256		// reduces amount of combinations below.
257		// Fully draws: ╋ ╂ ┃ ┿ ┼ │ ━ ─
258		for (unsigned topIndex = 0; topIndex < LinesNum/2; topIndex++) {
259		unsigned iB = (topIndex + 2) % LinesNum;
	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		const bool isSingleLine = (getLineType(topIndex) == LtLight
261		\|\| getLineType(topIndex) == LtHeavy);
262		if (isSingleLine && getLineType(topIndex) == getLineType(iB)) {
263		pathForLine(topIndex).moveTo(origin[topIndex]);
264		pathForLine(topIndex).lineTo(origin[iB]);
265		removeLineType(topIndex);
266		removeLineType(iB);
267		}
268		}
269
270		// Find base rotation of a character and map rotated line indices to the original rotation's
271		// indices. The base rotation is defined as the one with largest packedLineTypes value. This way
272		// we can use the same code for drawing 4 possible character rotations (see switch() below)
273
274		uint topIndex = 0; // index of an original top line in a base rotation
	sandsmarkUnsubmitted Done topIndex? sandsmark: topIndex?
275		quint8 basePackedLineTypes = packedLineTypes;
276		for (uint i = 0; i < LinesNum; i++) {
277		const quint8 rotatedPackedLineTypes = rotateBitsLeft(packedLineTypes, i * 2);
278		if (rotatedPackedLineTypes > basePackedLineTypes) {
279		topIndex = i;
280		basePackedLineTypes = rotatedPackedLineTypes;
281		}
282		}
283		uint rightIndex = (topIndex + 1) % LinesNum;
	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		uint bottomIndex = (topIndex + 2) % LinesNum;
285		uint leftIndex = (topIndex + 3) % LinesNum;
286
287		// Common paths
288		const auto drawDoubleUpRightShorterLine = [&](quint8 top, quint8 right) { // ╚
289		lightPath.moveTo(origin[top] + dir[right] * doubleLinesDistance);
290		lightPath.lineTo(center + (dir[right] + dir[top]) * doubleLinesDistance);
291		lightPath.lineTo(origin[right] + dir[top] * doubleLinesDistance);
292		};
293		const auto drawUpRight = [&](quint8 top, quint8 right) { // └┗
294		pathForLine(top).moveTo(origin[top]);
295		pathForLine(top).lineTo(center);
296		pathForLine(top).lineTo(origin[right]);
297		};
298
299		switch (basePackedLineTypes) {
300		case makePackedLineTypes(LtHeavy , LtNone , LtLight , LtNone ): // ╿ ; ╼ ╽ ╾ ╊ ╇ ╉ ╈ ╀ ┾ ╁ ┽
301		lightPath.moveTo(origin[bottomIndex]);
302		lightPath.lineTo(center + dir[topIndex] * lightLineWidth / 2.0);
303		Q_FALLTHROUGH();
304		case makePackedLineTypes(LtHeavy , LtNone , LtNone , LtNone ): // ╹ ; ╺ ╻ ╸ ┻ ┣ ┳ ┫ ┸ ┝ ┰ ┥
305		case makePackedLineTypes(LtLight , LtNone , LtNone , LtNone ): // ╵ ; ╶ ╷ ╴ ┷ ┠ ┯ ┨ ┴ ├ ┬ ┤
306		pathForLine(topIndex).moveTo(origin[topIndex]);
307		pathForLine(topIndex).lineTo(center);
308		break;
309
310		case makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtLight ): // ╄ ; ╃ ╆ ╅
311		drawUpRight(bottomIndex, leftIndex);
312		Q_FALLTHROUGH();
313		case makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtNone ): // ┗ ; ┛ ┏ ┓
314		case makePackedLineTypes(LtLight , LtLight , LtNone , LtNone ): // └ ; ┘ ┌ ┐
315		drawUpRight(topIndex, rightIndex);
316		break;
317
318		case makePackedLineTypes(LtHeavy , LtLight , LtNone , LtNone ): // ┖ ; ┙ ┍ ┒
319		qSwap(leftIndex, rightIndex);
320		Q_FALLTHROUGH();
321		case makePackedLineTypes(LtHeavy , LtNone , LtNone , LtLight ): // ┚ ; ┕ ┎ ┑
322		lightPath.moveTo(origin[leftIndex]);
323		lightPath.lineTo(center);
324		heavyPath.moveTo(origin[topIndex]);
325		heavyPath.lineTo(center + dir[bottomIndex] * lightLineWidth / 2.0);
326		break;
327
328		case makePackedLineTypes(LtLight , LtDouble, LtNone , LtNone ): // ╘ ; ╜ ╓ ╕
329		qSwap(leftIndex, rightIndex);
330		Q_FALLTHROUGH();
331		case makePackedLineTypes(LtLight , LtNone , LtNone , LtDouble): // ╛ ; ╙ ╒ ╖
332		lightPath.moveTo(origin[topIndex]);
333		lightPath.lineTo(center + dir[bottomIndex] * doubleLinesDistance);
334		lightPath.lineTo(origin[leftIndex] + dir[bottomIndex] * doubleLinesDistance);
335		lightPath.moveTo(origin[leftIndex] - dir[bottomIndex] * doubleLinesDistance);
336		lightPath.lineTo(center - dir[bottomIndex] * doubleLinesDistance);
337		break;
338
339		case makePackedLineTypes(LtHeavy , LtHeavy , LtLight , LtNone ): // ┡ ; ┹ ┪ ┲
340		qSwap(leftIndex, bottomIndex);
341		qSwap(rightIndex, topIndex);
342		Q_FALLTHROUGH();
343		case makePackedLineTypes(LtHeavy , LtHeavy , LtNone , LtLight ): // ┺ ; ┩ ┢ ┱
344		drawUpRight(topIndex, rightIndex);
345		lightPath.moveTo(origin[leftIndex]);
346		lightPath.lineTo(center);
347		break;
348
349		case makePackedLineTypes(LtHeavy , LtLight , LtLight , LtNone ): // ┞ ; ┵ ┧ ┮
350		qSwap(leftIndex, rightIndex);
351		Q_FALLTHROUGH();
352		case makePackedLineTypes(LtHeavy , LtNone , LtLight , LtLight ): // ┦ ; ┶ ┟ ┭
353		heavyPath.moveTo(origin[topIndex]);
354		heavyPath.lineTo(center + dir[bottomIndex] * lightLineWidth / 2.0);
355		drawUpRight(bottomIndex, leftIndex);
356		break;
357
358		case makePackedLineTypes(LtLight , LtDouble, LtNone , LtDouble): // ╧ ; ╟ ╢ ╤
359		lightPath.moveTo(origin[topIndex]);
360		lightPath.lineTo(center - dir[bottomIndex] * doubleLinesDistance);
361		qSwap(leftIndex, bottomIndex);
362		qSwap(rightIndex, topIndex);
363		Q_FALLTHROUGH();
364		case makePackedLineTypes(LtDouble, LtNone , LtDouble, LtNone ): // ║ ; ╫ ═ ╪
365		lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
366		lightPath.lineTo(origin[bottomIndex] + dir[leftIndex] * doubleLinesDistance);
367		lightPath.moveTo(origin[topIndex] + dir[rightIndex] * doubleLinesDistance);
368		lightPath.lineTo(origin[bottomIndex] + dir[rightIndex] * doubleLinesDistance);
369		break;
370
371		case makePackedLineTypes(LtDouble, LtNone , LtNone , LtNone ): // ╨ ; ╞ ╥ ╡
372		lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
373		lightPath.lineTo(center + dir[leftIndex] * doubleLinesDistance);
374		lightPath.moveTo(origin[topIndex] + dir[rightIndex] * doubleLinesDistance);
375		lightPath.lineTo(center + dir[rightIndex] * doubleLinesDistance);
376		break;
377
378		case makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtDouble): // ╬
379		drawDoubleUpRightShorterLine(topIndex, rightIndex);
380		drawDoubleUpRightShorterLine(bottomIndex, rightIndex);
381		drawDoubleUpRightShorterLine(topIndex, leftIndex);
382		drawDoubleUpRightShorterLine(bottomIndex, leftIndex);
383		break;
384
385		case makePackedLineTypes(LtDouble, LtDouble, LtDouble, LtNone ): // ╠ ; ╩ ╣ ╦
386		lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
387		lightPath.lineTo(origin[bottomIndex] + dir[leftIndex] * doubleLinesDistance);
388		drawDoubleUpRightShorterLine(topIndex, rightIndex);
389		drawDoubleUpRightShorterLine(bottomIndex, rightIndex);
390		break;
391
392		case makePackedLineTypes(LtDouble, LtDouble, LtNone , LtNone ): // ╚ ; ╝ ╔ ╗
393		lightPath.moveTo(origin[topIndex] + dir[leftIndex] * doubleLinesDistance);
394		lightPath.lineTo(center + (dir[leftIndex] + dir[bottomIndex]) * doubleLinesDistance);
395		lightPath.lineTo(origin[rightIndex] + dir[bottomIndex] * doubleLinesDistance);
396		drawDoubleUpRightShorterLine(topIndex, rightIndex);
397		break;
398		}
399
400		// Draw paths
401		if (!lightPath.isEmpty()) {
402		paint.strokePath(lightPath, lightPen);
403		}
404		if (!heavyPath.isEmpty()) {
405		paint.strokePath(heavyPath, heavyPen);
406		}
407
408		return true;
409		}
410
411		static inline bool drawDashedLineCharacter(QPainter &paint, int x, int y, int w, int h, uchar code,
412		bool bold)
413		{
414		if (!((0x04 <= code && code <= 0x0B) \|\| (0x4C <= code && code <= 0x4F))) {
415		return false;
416		}
417
418		const uint lightLineWidth = lineWidth(w, false, bold);
419		const uint heavyLineWidth = lineWidth(w, true, bold);
420
421		const auto lightPen = pen(paint, lightLineWidth);
422		const auto heavyPen = pen(paint, heavyLineWidth);
423
424		// Pixel aligned center point
425		const QPointF center = {
426		int(x + w/2.0) + 0.5 * (lightLineWidth%2),
427		int(y + h/2.0) + 0.5 * (lightLineWidth%2),
428		};
429
430		const qreal halfGapH = qMax(w / 20.0, 0.5);
431		const qreal halfGapV = qMax(h / 26.0, 0.5);
432		// For some reason vertical double dash has bigger gap
433		const qreal halfGapDDV = qMax(h / 14.0, 0.5);
434
435		static const int LinesNumMax = 4;
436
437		enum Orientation {Horizontal, Vertical};
438		struct {
439		int linesNum;
440		Orientation orientation;
441		QPen pen;
442		qreal halfGap;
443		} lineProps;
444
445		switch (code) {
446		case 0x4C: lineProps = {2, Horizontal, lightPen, halfGapH }; break; // ╌
447		case 0x4D: lineProps = {2, Horizontal, heavyPen, halfGapH }; break; // ╍
448		case 0x4E: lineProps = {2, Vertical , lightPen, halfGapDDV}; break; // ╎
449		case 0x4F: lineProps = {2, Vertical , heavyPen, halfGapDDV}; break; // ╏
450		case 0x04: lineProps = {3, Horizontal, lightPen, halfGapH }; 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 0x05: lineProps = {3, Horizontal, heavyPen, halfGapH }; break; // ┅
452		case 0x06: lineProps = {3, Vertical , lightPen, halfGapV }; break; // ┆
453		case 0x07: lineProps = {3, Vertical , heavyPen, halfGapV }; break; // ┇
454		case 0x08: lineProps = {4, Horizontal, lightPen, halfGapH }; break; // ┈
455		case 0x09: lineProps = {4, Horizontal, heavyPen, halfGapH }; break; // ┉
456		case 0x0A: lineProps = {4, Vertical , lightPen, halfGapV }; break; // ┊
457		case 0x0B: lineProps = {4, Vertical , heavyPen, halfGapV }; break; // ┋
458		}
459
460		Q_ASSERT(lineProps.linesNum <= LinesNumMax);
461		const int size = (lineProps.orientation == Horizontal ? w : h);
462		const int pos = (lineProps.orientation == Horizontal ? x : y);
463		QLineF lines[LinesNumMax];
464
465		for (int i = 0; i < lineProps.linesNum; i++) {
466		const qreal start = pos + qreal(size * (i )) / lineProps.linesNum;
467		const qreal end = pos + qreal(size * (i+1)) / lineProps.linesNum;
468		if (lineProps.orientation == Horizontal) {
469		lines[i] = QLineF{start + lineProps.halfGap, center.y(),
470		end - lineProps.halfGap, center.y()};
471		} else {
472		lines[i] = QLineF{center.x(), start + lineProps.halfGap,
473		center.x(), end - lineProps.halfGap};
474		}
475		}
476
477		const auto origPen = paint.pen();
478
479		paint.setPen(lineProps.pen);
480		paint.drawLines(lines, lineProps.linesNum);
481
482		paint.setPen(origPen);
483		return true;
484		}
485
486		static inline bool drawRoundedCornerLineCharacter(QPainter &paint, int x, int y, int w, int h,
487		uchar code, bool bold)
488		{
489		if (!(0x6D <= code && code <= 0x70)) {
490		return false;
491		}
492
493		const uint lightLineWidth = lineWidth(w, false, bold);
494		const auto lightPen = pen(paint, lightLineWidth);
495
496		// Pixel aligned center point
497		const QPointF center = {
498		int(x + w/2.0) + 0.5 * (lightLineWidth%2),
499		int(y + h/2.0) + 0.5 * (lightLineWidth%2),
500		};
501
502		const int r = w * 3 / 8;
503		const int d = 2 * r;
504
505		QPainterPath path;
506
507		// lineTo() between moveTo and arcTo is redundant - arcTo() draws line
508		// to the arc's starting point
509		switch (code) {
510		case 0x6D: // BOX DRAWINGS LIGHT ARC DOWN AND RIGHT
511		path.moveTo(center.x(), y + h);
512		path.arcTo(center.x(), center.y(), d, d, 180, -90);
513		path.lineTo(x + w, center.y());
514		break;
515		case 0x6E: // BOX DRAWINGS LIGHT ARC DOWN AND LEFT
516		path.moveTo(center.x(), y + h);
517		path.arcTo(center.x() - d, center.y(), d, d, 0, 90);
518		path.lineTo(x, center.y());
519		break;
520		case 0x6F: // BOX DRAWINGS LIGHT ARC UP AND LEFT
521		path.moveTo(center.x(), y);
522		path.arcTo(center.x() - d, center.y() - d, d, d, 0, -90);
523		path.lineTo(x, center.y());
524		break;
525		case 0x70: // BOX DRAWINGS LIGHT ARC UP AND RIGHT
526		path.moveTo(center.x(), y);
527		path.arcTo(center.x(), center.y() - d, d, d, 180, 90);
528		path.lineTo(x + w, center.y());
529		break;
530		}
531		paint.strokePath(path, lightPen);
532
533		return true;
534		}
535
536		static inline bool drawDiagonalLineCharacter(QPainter &paint, int x, int y, int w, int h,
537		uchar code, bool bold)
538		{
539		if (!(0x71 <= code && code <= 0x73)) {
540		return false;
541		}
542
543		const uint lightLineWidth = lineWidth(w, false, bold);
544		const auto lightPen = pen(paint, lightLineWidth);
545
546		const QLineF lines[] = {
547		QLineF(x+w, y, x , y+h), // '/'
548		QLineF(x , y, x+w, y+h), // '\'
549		};
550
551		const auto origPen = paint.pen();
552
553		paint.setPen(lightPen);
554		switch (code) {
555		case 0x71: // BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT
556		paint.drawLine(lines[0]);
557		break;
558		case 0x72: // BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT
559		paint.drawLine(lines[1]);
560		break;
561		case 0x73: // BOX DRAWINGS LIGHT DIAGONAL CROSS
562		paint.drawLines(lines, 2);
563		break;
564		}
565
566		paint.setPen(origPen);
567		return true;
568		}
569
570		static inline bool drawBlockCharacter(QPainter &paint, int x, int y, int w, int h, uchar code,
571		bool bold)
572		{
573		Q_UNUSED(bold);
574
575		const QColor color = paint.pen().color();
576
577		// Center point
578		const QPointF center = {
579		x + w/2.0,
580		y + h/2.0,
581		};
582
583		// Default rect fills entire cell
584		QRectF rect(x, y, w, h);
585
586		// LOWER ONE EIGHTH BLOCK to LEFT ONE EIGHTH BLOCK
587		if (code >= 0x81 && code <= 0x8f) {
588		if (code < 0x88) { // Horizontal
589		const qreal height = h * (0x88 - code) / 8.0;
590		rect.setY(y + height);
591		rect.setHeight(h - height);
592		} else if (code > 0x88) { // Vertical
593		const qreal width = w * (0x90 - code) / 8.0;
594		rect.setWidth(width);
595		}
596		paint.fillRect(rect, color);
597
598		return true;
599		}
600
601		// Combinations of quarter squares
602		// LEFT ONE EIGHTH BLOCK to QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT
603		if (code >= 0x96 && code <= 0x9F) {
604		const QRectF upperLeft (x , y , w/2.0, h/2.0);
605		const QRectF upperRight(center.x(), y , w/2.0, h/2.0);
606		const QRectF lowerLeft (x , center.y(), w/2.0, h/2.0);
607		const QRectF lowerRight(center.x(), center.y(), w/2.0, h/2.0);
608
609		QPainterPath path;
610
611		switch (code) {
612		case 0x96: // ▖
613		path.addRect(lowerLeft);
614		break;
615		case 0x97: // ▗
616		path.addRect(lowerRight);
617		break;
618		case 0x98: // ▘
619		path.addRect(upperLeft);
620		break;
621		case 0x99: // ▙
622		path.addRect(upperLeft);
623		path.addRect(lowerLeft);
624		path.addRect(lowerRight);
625		break;
626		case 0x9a: // ▚
627		path.addRect(upperLeft);
628		path.addRect(lowerRight);
629		break;
630		case 0x9b: // ▛
631		path.addRect(upperLeft);
632		path.addRect(upperRight);
633		path.addRect(lowerLeft);
634		break;
635		case 0x9c: // ▜
636		path.addRect(upperLeft);
637		path.addRect(upperRight);
638		path.addRect(lowerRight);
639		break;
640		case 0x9d: // ▝
641		path.addRect(upperRight);
642		break;
643		case 0x9e: // ▞
644		path.addRect(upperRight);
645		path.addRect(lowerLeft);
646		break;
647		case 0x9f: // ▟
648		path.addRect(upperRight);
649		path.addRect(lowerLeft);
650		path.addRect(lowerRight);
651		break;
652		}
653		paint.fillPath(path, color);
654
655		return true;
656		}
657
658		QBrush lightShade, mediumShade, darkShade;
659		if (paint.testRenderHint(QPainter::Antialiasing)) {
660		lightShade = QColor(color.red(), color.green(), color.blue(), 64);
661		mediumShade = QColor(color.red(), color.green(), color.blue(), 128);
662		darkShade = QColor(color.red(), color.green(), color.blue(), 192);
663		} else {
664		lightShade = QBrush(color, Qt::Dense6Pattern);
665		mediumShade = QBrush(color, Qt::Dense4Pattern);
666		darkShade = QBrush(color, Qt::Dense2Pattern);
667		}
668		// And the random stuff
669		switch (code) {
670		case 0x80: // Top half block
671		rect.setHeight(h/2.0);
672		paint.fillRect(rect, color);
673		return true;
674		case 0x90: // Right half block
675		rect.moveLeft(center.x());
676		paint.fillRect(rect, color);
677		return true;
678		case 0x94: // Top one eighth block
679		rect.setHeight(h/8.0);
680		paint.fillRect(rect, color);
681		return true;
682		case 0x95: { // Right one eighth block
683		const qreal width = 7 * w / 8.0;
684		rect.moveLeft(x + width);
685		paint.fillRect(rect, color);
686		return true;
687		}
688		case 0x91: // Light shade
689		paint.fillRect(rect, lightShade);
690		return true;
691		case 0x92: // Medium shade
692		paint.fillRect(rect, mediumShade);
693		return true;
694		case 0x93: // Dark shade
695		paint.fillRect(rect, darkShade);
696		return true;
697
698		default:
699		return false;
700		}
701		}
702
703		void draw(QPainter &paint, const QRect &cellRect, const QChar &chr, bool bold)
704		{
705		static const ushort FirstBoxDrawingCharacterCodePoint = 0x2500;
706		const uchar code = chr.unicode() - FirstBoxDrawingCharacterCodePoint;
707
708		int x = cellRect.x();
709		int y = cellRect.y();
710		int w = cellRect.width();
711		int h = cellRect.height();
712
713		// Each function below returns true when it has drawn the character, false otherwise.
714		drawBasicLineCharacter(paint, x, y, w, h, code, bold)
715		\|\| drawDashedLineCharacter(paint, x, y, w, h, code, bold)
716		\|\| drawRoundedCornerLineCharacter(paint, x, y, w, h, code, bold)
717		\|\| drawDiagonalLineCharacter(paint, x, y, w, h, code, bold)
718		\|\| drawBlockCharacter(paint, x, y, w, h, code, bold);
719		}
720
721		} // namespace LineBlockCharacters
722		} // namespace Konsole