mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/box-drawing.c

2364 lines
66 KiB
C
Raw Normal View History

box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
#include "box-drawing.h"
#include <stdio.h>
#include <errno.h>
#define LOG_MODULE "box-drawing"
box-drawing: disable debug output
2021-01-01 21:27:53 +01:00
#define LOG_ENABLE_DBG 0
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
#include "log.h"
box-drawing: compensate for non-zero {horizontal,vertical}-letter-offsets Box drawing characters should always cover the entire cell. No more, no less.
2021-01-07 11:18:25 +01:00
#include "config.h"
box-drawing: thickness(): tag as CONST, convert point-size to a float
2020-12-27 16:14:37 +01:00
#include "macros.h"
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
#include "stride.h"
#include "terminal.h"
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
#include "util.h"
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
#include "xmalloc.h"
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
enum thickness {
LIGHT = 1,
HEAVY = 3,
};
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
struct buf {
uint8_t *data;
box-drawing: include pixman image in the buffer we’re passing around
2021-05-05 14:59:53 +02:00
pixman_image_t *pix;
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int width;
int height;
int stride;
int dpi;
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
float cell_size;
float base_thickness;
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
};
box-drawing: {h,v}line: implement using pixman Use pixman_image_fill_rectangles() to render horizontal and vertical lines. Despite the name, this *is* the appropriate function to use, since our lines *do* have a thickness, and thus *are* rectangles.
2021-05-05 15:01:57 +02:00
static const pixman_color_t white = {0xffff, 0xffff, 0xffff, 0xffff};
box-drawing: remove __attribute__((__const__)) from thickness() thickness() is a static function and thus ‘const’ is not necessary.
2020-12-29 10:41:38 +01:00
static int
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
_thickness(struct buf *buf, enum thickness thick)
box-drawing: break out thickness calculation
2020-12-26 20:57:17 +01:00
{
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
return max((int)(buf->base_thickness * buf->dpi / 72.0 * buf->cell_size), 1) * thick;
box-drawing: break out thickness calculation
2020-12-26 20:57:17 +01:00
}
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
#define thickness(thick) _thickness(buf, thick)
box-drawing: break out thickness calculation
2020-12-26 20:57:17 +01:00
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
_hline(struct buf *buf, int x1, int x2, int y, int thick)
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
x1 = min(max(x1, 0), buf->width);
x2 = min(max(x2, 0), buf->width);
box-drawing: {h,v}line(): handle both start/end point being too small *and* too large
2020-12-30 13:30:39 +01:00
box-drawing: {h,v}line: implement using pixman Use pixman_image_fill_rectangles() to render horizontal and vertical lines. Despite the name, this *is* the appropriate function to use, since our lines *do* have a thickness, and thus *are* rectangles.
2021-05-05 15:01:57 +02:00
int y1 = max(y, 0);
int y2 = min(max(y + thick, 0), buf->height);
int width = x2 - x1;
int height = y2 - y1;
pixman_rectangle16_t rect = {
.x = x1, .y = y1, .width = width, .height = height};
pixman_image_fill_rectangles(PIXMAN_OP_SRC, buf->pix, &white, 1, &rect);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
#define hline(x1, x2, y, thick) _hline(buf, x1, x2, y, thick)
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
_vline(struct buf *buf, int y1, int y2, int x, int thick)
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
y1 = min(max(y1, 0), buf->height);
y2 = min(max(y2, 0), buf->height);
box-drawing: {h,v}line(): handle both start/end point being too small *and* too large
2020-12-30 13:30:39 +01:00
box-drawing: {h,v}line: implement using pixman Use pixman_image_fill_rectangles() to render horizontal and vertical lines. Despite the name, this *is* the appropriate function to use, since our lines *do* have a thickness, and thus *are* rectangles.
2021-05-05 15:01:57 +02:00
int x1 = max(x, 0);
int x2 = min(max(x + thick, 0), buf->width);
int width = x2 - x1;
int height = y2 - y1;
pixman_rectangle16_t rect = {
.x = x1, .y = y1, .width = width, .height = height};
pixman_image_fill_rectangles(PIXMAN_OP_SRC, buf->pix, &white, 1, &rect);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
#define vline(y1, y2, x, thick) _vline(buf, y1, y2, x, thick)
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
_rect(struct buf *buf, int x1, int y1, int x2, int y2)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: rect(): implement using pixman Use pixman_image_fill_rectangles() to render rectangles. Duh!
2021-05-05 15:03:04 +02:00
x1 = min(max(x1, 0), buf->width);
y1 = min(max(y1, 0), buf->height);
x2 = min(max(x2, 0), buf->width);
y2 = min(max(y2, 0), buf->height);
int width = x2 - x1;
int height = y2 - y1;
assert(x1 + width <= buf->width);
assert(y1 + height <= buf->height);
pixman_rectangle16_t rect = {
.x = x1, .y = y1, .width = width, .height = height};
pixman_image_fill_rectangles(PIXMAN_OP_SRC, buf->pix, &white, 1, &rect);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
#define rect(x1, y1, x2, y2) _rect(buf, x1, y1, x2, y2)
box-drawing: make sure we never walk outside the (image) buffer
2020-12-29 19:42:56 +01:00
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
_hline_middle(struct buf *buf, enum thickness _thick)
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
{
int thick = thickness(_thick);
hline(0, buf->width, (buf->height - thick) / 2, thick);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
_hline_middle_left(struct buf *buf, enum thickness _vthick, enum thickness _hthick)
box-drawing: convert {h,v}line_middle_{left,right,up,down}() macros to functions This greatly reduces the size of the foot binary
2021-01-01 22:12:40 +01:00
{
int vthick = thickness(_vthick);
int hthick = thickness(_hthick);
_hline(buf, 0, (buf->width + vthick) / 2, (buf->height - hthick) / 2, hthick);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
_hline_middle_right(struct buf *buf, enum thickness _vthick, enum thickness _hthick)
box-drawing: convert {h,v}line_middle_{left,right,up,down}() macros to functions This greatly reduces the size of the foot binary
2021-01-01 22:12:40 +01:00
{
int vthick = thickness(_vthick);
int hthick = thickness(_hthick);
hline((buf->width - vthick) / 2, buf->width, (buf->height - hthick) / 2, hthick);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
_vline_middle(struct buf *buf, enum thickness _thick)
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
{
int thick = thickness(_thick);
vline(0, buf->height, (buf->width - thick) / 2, thick);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
_vline_middle_up(struct buf *buf, enum thickness _vthick, enum thickness _hthick)
box-drawing: convert {h,v}line_middle_{left,right,up,down}() macros to functions This greatly reduces the size of the foot binary
2021-01-01 22:12:40 +01:00
{
int vthick = thickness(_vthick);
int hthick = thickness(_hthick);
vline(0, (buf->height + hthick) / 2, (buf->width - vthick) / 2, vthick);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
_vline_middle_down(struct buf *buf, enum thickness _vthick, enum thickness _hthick)
box-drawing: convert {h,v}line_middle_{left,right,up,down}() macros to functions This greatly reduces the size of the foot binary
2021-01-01 22:12:40 +01:00
{
int vthick = thickness(_vthick);
int hthick = thickness(_hthick);
vline((buf->height - hthick) / 2, buf->height, (buf->width - vthick) / 2, vthick);
}
box-drawing: make sure we never walk outside the (image) buffer
2020-12-29 19:42:56 +01:00
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
#define hline_middle(thick) _hline_middle(buf, thick)
box-drawing: convert {h,v}line_middle_{left,right,up,down}() macros to functions This greatly reduces the size of the foot binary
2021-01-01 22:12:40 +01:00
#define hline_middle_left(thick) _hline_middle_left(buf, thick, thick)
#define hline_middle_right(thick) _hline_middle_right(buf, thick, thick)
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
#define hline_middle_left_mixed(vthick, hthick) _hline_middle_left(buf, vthick, hthick)
#define hline_middle_right_mixed(vthick, hthick) _hline_middle_right(buf, vthick, hthick)
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
#define vline_middle(thick) _vline_middle(buf, thick)
box-drawing: convert {h,v}line_middle_{left,right,up,down}() macros to functions This greatly reduces the size of the foot binary
2021-01-01 22:12:40 +01:00
#define vline_middle_up(thick) _vline_middle_up(buf, thick, thick)
#define vline_middle_down(thick) _vline_middle_down(buf, thick, thick)
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
#define vline_middle_up_mixed(vthick, hthick) _vline_middle_up(buf, vthick, hthick)
#define vline_middle_down_mixed(vthick, hthick) _vline_middle_down(buf, vthick, hthick)
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_horizontal(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_horizontal(struct buf *buf)
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_vertical(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_vertical(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_horizontal(struct buf *buf, int count, int thick, int gap)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int width = buf->width;
int height = buf->height;
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(count >= 2 && count <= 4);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
const int gap_count = count - 1;
int dash_width = (width - (gap_count * gap)) / count;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
while (dash_width <= 0 && gap > 1) {
gap--;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
dash_width = (width - (gap_count * gap)) / count;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
if (dash_width <= 0) {
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
return;
}
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(count * dash_width + gap_count * gap <= width);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
int remaining = width - count * dash_width - gap_count * gap;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: silence variable-may-not-be-initialized warnings
2021-01-01 21:00:27 +01:00
int x[4] = {0};
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
int w[4] = {dash_width, dash_width, dash_width, dash_width};
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
x[0] = 0;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
x[1] = x[0] + w[0] + gap;
if (count == 2)
w[1] = width - x[1];
else if (count == 3)
w[1] += remaining;
else
w[1] += remaining / 2;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
if (count >= 3) {
x[2] = x[1] + w[1] + gap;
if (count == 3)
w[2] = width - x[2];
else
w[2] += remaining - remaining / 2;
}
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
if (count >= 4) {
x[3] = x[2] + w[2] + gap;
w[3] = width - x[3];
}
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
hline(x[0], x[0] + w[0], (height - thick) / 2, thick);
hline(x[1], x[1] + w[1], (height - thick) / 2, thick);
if (count >= 3)
hline(x[2], x[2] + w[2], (height - thick) / 2, thick);
if (count >= 4)
hline(x[3], x[3] + w[3], (height - thick) / 2, thick);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_vertical(struct buf *buf, int count, int thick, int gap)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int width = buf->width;
int height = buf->height;
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(count >= 2 && count <= 4);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
const int gap_count = count - 1;
int dash_height = (height - (gap_count * gap)) / count;
while (dash_height <= 0 && gap > 1) {
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
gap--;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
dash_height = (height - (gap_count * gap)) / count;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
if (dash_height <= 0) {
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
return;
}
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(count * dash_height + gap_count * gap <= height);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
int remaining = height - count * dash_height - gap_count * gap;
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: silence variable-may-not-be-initialized warnings
2021-01-01 21:00:27 +01:00
int y[4] = {0};
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
int h[4] = {dash_height, dash_height, dash_height, dash_height};
y[0] = 0;
y[1] = y[0] + h[0] + gap;
if (count == 2)
h[1] = height - y[1];
else if (count == 3)
h[1] += remaining;
else
h[1] += remaining / 2;
if (count >= 3) {
y[2] = y[1] + h[1] + gap;
if (count == 3)
h[2] = height - y[2];
else
h[2] += remaining - remaining / 2;
}
if (count >= 4) {
y[3] = y[2] + h[2] + gap;
h[3] = height - y[3];
}
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
vline(y[0], y[0] + h[0], (width - thick) / 2, thick);
vline(y[1], y[1] + h[1], (width - thick) / 2, thick);
if (count >= 3)
vline(y[2], y[2] + h[2], (width - thick) / 2, thick);
if (count >= 4)
vline(y[3], y[3] + h[3], (width - thick) / 2, thick);
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_triple_dash_horizontal(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_horizontal(buf, 3, thickness(LIGHT), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_triple_dash_horizontal(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_horizontal(buf, 3, thickness(HEAVY), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_triple_dash_vertical(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_vertical(buf, 3, thickness(LIGHT), thickness(HEAVY));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_triple_dash_vertical(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_vertical(buf, 3, thickness(HEAVY), thickness(HEAVY));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_quadruple_dash_horizontal(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_horizontal(buf, 4, thickness(LIGHT), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_quadruple_dash_horizontal(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_horizontal(buf, 4, thickness(HEAVY), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_quadruple_dash_vertical(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_vertical(buf, 4, thickness(LIGHT), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_quadruple_dash_vertical(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_vertical(buf, 4, thickness(HEAVY), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_down_and_right(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
vline_middle_down(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_light_and_right_heavy(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_right_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_heavy_and_right_light(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_down_mixed(HEAVY, LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_down_and_right(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(HEAVY);
vline_middle_down(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_down_and_left(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
vline_middle_down(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_light_and_left_heavy(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_left_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_heavy_and_left_light(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_down_mixed(HEAVY, LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_down_and_left(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
vline_middle_down(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_up_and_right(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
vline_middle_up(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_light_and_right_heavy(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_right_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_heavy_and_right_light(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_up_mixed(HEAVY, LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_up_and_right(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(HEAVY);
vline_middle_up(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_up_and_left(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
vline_middle_up(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_light_and_left_heavy(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_left_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_heavy_and_left_light(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_up_mixed(HEAVY, LIGHT);
box-drawing: add mixed LIGHT/HEAVY corners * U+250D * U+250E * U+2511 * U+2512 * U+2515 * U+2516 * U+2519 * U+251A
2020-12-26 22:58:08 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_up_and_left(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
vline_middle_up(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_vertical_and_right(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_light_and_right_heavy(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_right_mixed(LIGHT, HEAVY);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_heavy_and_right_down_light(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_up_mixed(HEAVY, LIGHT);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_heavy_and_right_up_light(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
vline_middle_up(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_down_mixed(HEAVY, LIGHT);
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_heavy_and_right_light(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(HEAVY);
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_light_and_right_up_heavy(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(HEAVY);
vline_middle_up(HEAVY);
vline_middle_down(LIGHT);
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_light_and_right_down_heavy(struct buf *buf)
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(HEAVY);
vline_middle_up(LIGHT);
vline_middle_down(HEAVY);
box-drawing: add mixed LIGHT/HEAVY VERTICAL AND RIGHT * U+251D * U+251E * U+251F * U+2520 * U+2521 * U+2522
2020-12-26 23:14:54 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_vertical_and_right(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(HEAVY);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_vertical_and_left(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_light_and_left_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_left_mixed(LIGHT, HEAVY);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_heavy_and_left_down_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_up_mixed(HEAVY, LIGHT);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_heavy_and_left_up_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
vline_middle_up(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_down_mixed(HEAVY, LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_heavy_and_left_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_light_and_left_up_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
vline_middle_up(HEAVY);
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_light_and_left_down_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
vline_middle_up(LIGHT);
vline_middle_down(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND LEFT * U+2525 * U+2526 * U+2527 * U+2528 * U+2529 * U+252A
2020-12-27 12:12:24 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_vertical_and_left(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_down_and_horizontal(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_heavy_and_right_down_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_left_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_heavy_and_left_down_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_right_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_light_and_horizontal_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_heavy_and_horizontal_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_down_mixed(HEAVY, LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_light_and_left_down_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
hline_middle_right(LIGHT);
vline_middle_down(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_light_and_right_down_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
hline_middle_right(HEAVY);
vline_middle_down(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of DOWN AND HORIZONTAL * U+252d * U+252e * U+252f * U+2530 * U+2531 * U+2532
2020-12-27 12:21:37 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_down_and_horizontal(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(HEAVY);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_up_and_horizontal(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_heavy_and_right_up_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_left_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
vline_middle_up(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_heavy_and_left_up_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_right_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_light_and_horizontal_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_heavy_and_horizontal_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_up_mixed(HEAVY, LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_light_and_left_up_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
hline_middle_right(LIGHT);
vline_middle_up(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_light_and_right_up_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
hline_middle_right(HEAVY);
vline_middle_up(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of UP AND HORIZONTAL * U+2535 * U+2536 * U+2537 * U+2538 * U+2539 * U+253A
2020-12-27 12:29:44 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_up_and_horizontal(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(HEAVY);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_vertical_and_horizontal(struct buf *buf)
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
vline_middle(LIGHT);
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
}
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_heavy_and_right_vertical_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_left_mixed(LIGHT, HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_heavy_and_left_vertical_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
hline_middle_right_mixed(LIGHT, HEAVY);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_light_and_horizontal_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
vline_middle(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_heavy_and_down_horizontal_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_up_mixed(HEAVY, LIGHT);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_heavy_and_up_horizontal_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
box-drawing: add macros for {h,v}line_middle_mixed() Mixed here refers to mixed thickness - the lines thickness doesn’t match the thickness of an abstract, orthogonal line going through the middle of the cell.
2021-01-02 12:28:03 +01:00
vline_middle_down_mixed(HEAVY, LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_heavy_and_horizontal_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
vline_middle(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_up_heavy_and_right_down_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
hline_middle_right(LIGHT);
vline_middle_up(HEAVY);
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_up_heavy_and_left_down_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
hline_middle_right(HEAVY);
vline_middle_up(HEAVY);
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_down_heavy_and_right_up_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
hline_middle_right(LIGHT);
vline_middle_up(LIGHT);
vline_middle_down(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_down_heavy_and_left_up_light(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
hline_middle_right(HEAVY);
vline_middle_up(LIGHT);
vline_middle_down(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_light_and_up_horizontal_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(HEAVY);
vline_middle_down(LIGHT);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_light_and_down_horizontal_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
vline_middle_down(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_right_light_and_left_vertical_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
hline_middle_right(LIGHT);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_left_light_and_right_vertical_heavy(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
hline_middle_right(HEAVY);
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(HEAVY);
box-drawing: mixed LIGHT/HEAVY variants of VERTICAL AND HORIZONTAL * U+253D * U+253E * U+253F * U+2540 * U+2541 * U+2542 * U+2542 * U+2543 * U+2544 * U+2545 * U+2546 * U+2547 * U+2548 * U+2549 * U+254A
2020-12-27 12:44:02 +01:00
}
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_vertical_and_horizontal(struct buf *buf)
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
{
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(HEAVY);
vline_middle(HEAVY);
box-drawing: HEAVY versions of solid lines
2020-12-26 21:21:58 +01:00
}
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_double_dash_horizontal(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_horizontal(buf, 2, thickness(LIGHT), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_double_dash_horizontal(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_horizontal(buf, 2, thickness(HEAVY), thickness(LIGHT));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_double_dash_vertical(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_vertical(buf, 2, thickness(LIGHT), thickness(HEAVY));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_double_dash_vertical(struct buf *buf)
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE VERTICAL Also combine the HORIZONTAL versions into a single draw function. * U+2506 * U+2507 * U+250A * U+250B * U+254E * U+254F
2021-01-01 20:33:38 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_dash_vertical(buf, 2, thickness(HEAVY), thickness(HEAVY));
box-drawing: LIGHT/HEAVY DOUBLE/TRIPLE/QUADRUPLE HORIZONTAL *U+2504 *U+2505 *U+2508 *U+2509 *U+254C *U+254D
2021-01-01 14:06:48 +01:00
}
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_horizontal(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int mid = (buf->height - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(0, buf->width, mid, thick);
hline(0, buf->width, mid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_vertical(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int mid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(0, buf->height, mid, thick);
vline(0, buf->height, mid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_single_and_right_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
vline_middle_down(LIGHT);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid, buf->width, hmid, thick);
hline(vmid, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_double_and_right_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
hline_middle_right(LIGHT);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid, buf->height, vmid, thick);
vline(hmid, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_down_and_right(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid, buf->height, vmid, thick);
vline(hmid + 2 * thick, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid, buf->width, hmid, thick);
hline(vmid + 2 * thick, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_single_and_left_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width + thick) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
vline_middle_down(LIGHT);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid, hmid, thick);
hline(0, vmid, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_double_and_left_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
hline_middle_left(LIGHT);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid, buf->height, vmid, thick);
vline(hmid, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_down_and_left(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid + 2 * thick, buf->height, vmid, thick);
vline(hmid, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid + 2 * thick, hmid, thick);
hline(0, vmid, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_single_and_right_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
vline_middle_up(LIGHT);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid, buf->width, hmid, thick);
hline(vmid, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_double_and_right_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height + thick) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
hline_middle_right(LIGHT);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid, thick);
vline(0, hmid, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_up_and_right(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid + 2 * thick, vmid, thick);
vline(0, hmid, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid + 2 * thick, buf->width, hmid, thick);
hline(vmid, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_single_and_left_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width + thick) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
vline_middle_up(LIGHT);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid, hmid, thick);
hline(0, vmid, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_double_and_left_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height + thick) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
hline_middle_left(LIGHT);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid, thick);
vline(0, hmid, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_up_and_left(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid + 0 * thick + thick, vmid, thick);
vline(0, hmid + 2 * thick + thick, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid, hmid, thick);
hline(0, vmid + 2 * thick, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_single_and_right_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid, buf->width, hmid, thick);
hline(vmid, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_double_and_right_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid + 2 * thick, buf->width, (buf->height - thick) / 2, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(0, buf->height, vmid, thick);
vline(0, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_vertical_and_right(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(0, buf->height, vmid, thick);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid + 2 * thick, thick);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid + 2 * thick, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid + 2 * thick, buf->width, hmid, thick);
hline(vmid + 2 * thick, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_single_and_left_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width + thick) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid, hmid, thick);
hline(0, vmid, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_double_and_left_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(0, vmid, (buf->height - thick) / 2, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(0, buf->height, vmid, thick);
vline(0, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_vertical_and_left(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(0, buf->height, vmid + 2 * thick, thick);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid, thick);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid + 2 * thick, buf->height, vmid, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid + thick, hmid, thick);
hline(0, vmid, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_single_and_horizontal_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid + 2 * thick, buf->height, (buf->width - thick) / 2, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(0, buf->width, hmid, thick);
hline(0, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_down_double_and_horizontal_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid, buf->height, vmid, thick);
vline(hmid, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_down_and_horizontal(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(0, buf->width, hmid, thick);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid, hmid + 2 * thick, thick);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid + 2 * thick, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid + 2 * thick, buf->height, vmid, thick);
vline(hmid + 2 * thick, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_single_and_horizontal_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(0, buf->width, hmid, thick);
hline(0, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_up_double_and_horizontal_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid, thick);
vline(0, hmid, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_up_and_horizontal(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid, thick);
vline(0, hmid, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid + thick, hmid, thick);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid + 2 * thick, buf->width, hmid, thick);
hline(0, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_single_and_horizontal_double(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
vline_middle(LIGHT);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(0, buf->width, hmid, thick);
hline(0, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_vertical_double_and_horizontal_single(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: dedicated functions to draw a full horizontal/vertical line
2021-01-01 22:24:52 +01:00
hline_middle(LIGHT);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(0, buf->height, vmid, thick);
vline(0, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_double_vertical_and_horizontal(struct buf *buf)
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
int hmid = (buf->height - thick * 3) / 2;
int vmid = (buf->width - thick * 3) / 2;
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid, hmid, thick);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid + 2 * thick, buf->width, hmid, thick);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
hline(0, vmid, hmid + 2 * thick, thick);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
hline(vmid + 2 * thick, buf->width, hmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
box-drawing: U+256C - BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL: add missing corner The inner corner, where the upper/left lines meet, were missing
2021-05-05 15:00:17 +02:00
vline(0, hmid + thick, vmid, thick);
box-drawing: wrap {h,v}hline() functions in macros, to shorten argument list Rename the *function* {h,v}line() to _{h,v}line(), and add two new macros: hline() and vline(). This allows us to shorten the argument list by removing the ‘buf’ and ‘stride’ arguments.
2020-12-29 19:38:02 +01:00
vline(0, hmid, vmid + 2 * thick, thick);
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
vline(hmid + 2 * thick, buf->height, vmid, thick);
vline(hmid + 2 * thick, buf->height, vmid + 2 * thick, thick);
box-drawing: DOUBLE lines, U+2550-U+256C
2020-12-28 14:08:57 +01:00
}
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_arc(wchar_t wc, struct buf *buf)
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
int thick = thickness(LIGHT);
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
double a = (buf->width - thick) / 2;
double b = (buf->height - thick) / 2;
box-drawing: LIGHT ARC: pixel-perfect At least in odd-sized cells, with a thickness of 1 pixel.
2021-01-01 12:47:57 +01:00
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
double a2 = a * a;
double b2 = b * b;
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
int num_samples = buf->height * 16;
for (int i = 0; i < num_samples; i++) {
double y = i / 16.;
double x = sqrt(a2 * (1. - y * y / b2));
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
const int row = round(y);
const int col = round(x);
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
if (col < 0)
continue;
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
int row_start = 0;
int row_end = 0;
int col_start = 0;
int col_end = 0;
/*
* At this point, row/col is only correct for ╯. For the other
* arcs, we need to mirror the arc around either the x-, y- or
* both axis.
box-drawing: LIGHT ARC: simpler way to adjust for asymmetrical arc when mirroring When mirroring an arc, we need to adjust the mirrored position if the arc’s position in the cell is asymmetrical. This happens when *either* the line is odd sized, *or* the cell is. But not when both are. Thus, we can simply do a ‘thickness % 2 ^ width % 2’ when adjusting the position. Describe this in a comment.
2021-01-02 12:09:00 +01:00
*
box-drawing: codespell: assymetrical -> asymmetrical
2021-01-02 12:35:53 +01:00
* When doing so, we need to adjust for asymmetrical cell
box-drawing: LIGHT ARC: simpler way to adjust for asymmetrical arc when mirroring When mirroring an arc, we need to adjust the mirrored position if the arc’s position in the cell is asymmetrical. This happens when *either* the line is odd sized, *or* the cell is. But not when both are. Thus, we can simply do a ‘thickness % 2 ^ width % 2’ when adjusting the position. Describe this in a comment.
2021-01-02 12:09:00 +01:00
* dimensions.
*
* The amazing box drawing art below represents the lower part
* of a cell, with the beginning of a vertical line in the
* middle. Each column represents one pixel.
*
*
* Even cell Odd cell
*
* │ │ │ │
* Even line │ ┆ ┆ │ │ ┆ ┆ │
* │ ┆ ┆ │ │ ┆ ┆ │
* └─┴─┴─┴─┘ └─┴─┴─┴─┴─┘
*
*
* │ │ │ │
* Odd line │ ┆ ┆ │ │ ┆ ┆ │
* │ ┆ ┆ │ │ ┆ ┆ │
* └─┴─┴─┴─┘ └─┴─┴─┴─┴─┘
*
box-drawing: codespell: assymetrical -> asymmetrical
2021-01-02 12:35:53 +01:00
* As can be seen(?), the resulting line is asymmetrical when
box-drawing: LIGHT ARC: simpler way to adjust for asymmetrical arc when mirroring When mirroring an arc, we need to adjust the mirrored position if the arc’s position in the cell is asymmetrical. This happens when *either* the line is odd sized, *or* the cell is. But not when both are. Thus, we can simply do a ‘thickness % 2 ^ width % 2’ when adjusting the position. Describe this in a comment.
2021-01-02 12:09:00 +01:00
* *either* the cell is odd sized, *or* the line is odd
* sized. But not when both are.
*
* Hence the ‘thick % 2 ^ width % 2’ in the expressions below.
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
*/
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
switch (wc) {
case L'╭':
box-drawing: LIGHT ARC: simpler way to adjust for asymmetrical arc when mirroring When mirroring an arc, we need to adjust the mirrored position if the arc’s position in the cell is asymmetrical. This happens when *either* the line is odd sized, *or* the cell is. But not when both are. Thus, we can simply do a ‘thickness % 2 ^ width % 2’ when adjusting the position. Describe this in a comment.
2021-01-02 12:09:00 +01:00
row_end = buf->height - row - (thick % 2 ^ buf->height % 2);
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
row_start = row_end - thick;
box-drawing: LIGHT ARC: simpler way to adjust for asymmetrical arc when mirroring When mirroring an arc, we need to adjust the mirrored position if the arc’s position in the cell is asymmetrical. This happens when *either* the line is odd sized, *or* the cell is. But not when both are. Thus, we can simply do a ‘thickness % 2 ^ width % 2’ when adjusting the position. Describe this in a comment.
2021-01-02 12:09:00 +01:00
col_end = buf->width - col - (thick % 2 ^ buf->width % 2);
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
col_start = col_end - thick;
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
break;
box-drawing: LIGHT ARC: pixel-perfect At least in odd-sized cells, with a thickness of 1 pixel.
2021-01-01 12:47:57 +01:00
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
case L'╮':
box-drawing: LIGHT ARC: simpler way to adjust for asymmetrical arc when mirroring When mirroring an arc, we need to adjust the mirrored position if the arc’s position in the cell is asymmetrical. This happens when *either* the line is odd sized, *or* the cell is. But not when both are. Thus, we can simply do a ‘thickness % 2 ^ width % 2’ when adjusting the position. Describe this in a comment.
2021-01-02 12:09:00 +01:00
row_end = buf->height - row - (thick % 2 ^ buf->height % 2);
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
row_start = row_end - thick;
col_start = col;
col_end = col_start + thick;
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
break;
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
case L'╰':
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
row_start = row;
row_end = row_start + thick;
box-drawing: LIGHT ARC: simpler way to adjust for asymmetrical arc when mirroring When mirroring an arc, we need to adjust the mirrored position if the arc’s position in the cell is asymmetrical. This happens when *either* the line is odd sized, *or* the cell is. But not when both are. Thus, we can simply do a ‘thickness % 2 ^ width % 2’ when adjusting the position. Describe this in a comment.
2021-01-02 12:09:00 +01:00
col_end = buf->width - col - (thick % 2 ^ buf->width % 2);
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
col_start = col_end - thick;
break;
case L'╯':
row_start = row;
row_end = row_start + thick;
col_start = col;
col_end = col_start + thick;
box-drawing: LIGHT ARC: test using a circle equation instead of a bezier curve
2021-01-02 00:52:02 +01:00
break;
}
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(row_end > row_start);
xassert(col_end > col_start);
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
box-drawing: LIGHT ARC: ensure row+col are within range
2021-01-08 10:27:16 +01:00
for (int r = max(row_start, 0); r < max(min(row_end, buf->height), 0); r++) {
for (int c = max(col_start, 0); c < max(min(col_end, buf->width), 0); c++) {
box-drawing: LIGHT ARC: use min/max instead of checking range inside loop
2021-01-02 12:08:32 +01:00
size_t idx = c / 8;
size_t bit_no = c % 8;
buf->data[r * buf->stride + idx] |= 1 << bit_no;
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
}
}
}
box-drawing: LIGHT ARC: improve symmetry when cell width is even
2021-01-01 13:18:51 +01:00
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
/*
* Since a cell may not be completely symmetrical around its y-
* and x-axis, the mirroring done above may result in the last
* col/row of the arc not being filled in. This code ensures they
* are.
*/
box-drawing: LIGHT ARC: improve symmetry when cell width is even
2021-01-01 13:18:51 +01:00
if (wc == L'╭' || wc == L'╰') {
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
for (int y = 0; y < thick; y++) {
int row = (buf->height - thick) / 2 + y;
int col = buf->width - 1;
box-drawing: LIGHT ARC: ensure row+col are within range
2021-01-08 10:27:16 +01:00
if (row >= 0 && row < buf->height && col >= 0 && col < buf->width) {
size_t ofs = col / 8;
size_t bit_no = col % 8;
buf->data[row * buf->stride + ofs] |= 1 << bit_no;
}
box-drawing: LIGHT ARC: improve symmetry when cell width is even
2021-01-01 13:18:51 +01:00
}
}
if (wc == L'╭' || wc == L'╮') {
box-drawing: LIGHT ARC: fix alignment of arcs when thickness is > 1px
2021-01-02 02:26:12 +01:00
for (int x = 0; x < thick; x++) {
int row = buf->height - 1;
int col = (buf->width - thick) / 2 + x;
box-drawing: LIGHT ARC: ensure row+col are within range
2021-01-08 10:27:16 +01:00
if (row >= 0 && row < buf->height && col >= 0 && col < buf->width) {
size_t ofs = col / 8;
size_t bit_no = col % 8;
buf->data[row * buf->stride + ofs] |= 1 << bit_no;
}
box-drawing: LIGHT ARC: improve symmetry when cell width is even
2021-01-01 13:18:51 +01:00
}
}
box-drawing: wip: LIGHT ARC: U+256d-U+2570
2020-12-31 17:22:14 +01:00
}
box-drawing: LIGHT DIAGONALs * U+2571 * U+2572 * U+2573
2021-01-01 21:01:02 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_diagonal_upper_right_to_lower_left(struct buf *buf)
box-drawing: LIGHT DIAGONALs * U+2571 * U+2572 * U+2573
2021-01-01 21:01:02 +01:00
{
box-drawing: implement LIGHT diagonal lines using pixman Use trapezoids to rasterize the diagonal lines.
2021-05-05 15:03:30 +02:00
pixman_trapezoid_t trap = {
.top = pixman_int_to_fixed(0),
.bottom = pixman_int_to_fixed(buf->height),
.left = {
.p1 = {
.x = pixman_double_to_fixed(buf->width - thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(0),
},
.p2 = {
.x = pixman_double_to_fixed(0 - thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(buf->height),
},
},
.right = {
.p1 = {
.x = pixman_double_to_fixed(buf->width + thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(0),
},
.p2 = {
.x = pixman_double_to_fixed(0 + thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(buf->height),
},
},
};
pixman_rasterize_trapezoid(buf->pix, &trap, 0, 0);
box-drawing: LIGHT DIAGONALs * U+2571 * U+2572 * U+2573
2021-01-01 21:01:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_diagonal_upper_left_to_lower_right(struct buf *buf)
box-drawing: LIGHT DIAGONALs * U+2571 * U+2572 * U+2573
2021-01-01 21:01:02 +01:00
{
box-drawing: implement LIGHT diagonal lines using pixman Use trapezoids to rasterize the diagonal lines.
2021-05-05 15:03:30 +02:00
pixman_trapezoid_t trap = {
.top = pixman_int_to_fixed(0),
.bottom = pixman_int_to_fixed(buf->height),
.left = {
.p1 = {
.x = pixman_double_to_fixed(0 - thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(0),
},
.p2 = {
.x = pixman_double_to_fixed(buf->width - thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(buf->height),
},
},
.right = {
.p1 = {
.x = pixman_double_to_fixed(0 + thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(0),
},
.p2 = {
.x = pixman_double_to_fixed(buf->width + thickness(LIGHT) / 2.),
.y = pixman_int_to_fixed(buf->height),
},
},
};
pixman_rasterize_trapezoid(buf->pix, &trap, 0, 0);
box-drawing: LIGHT DIAGONALs * U+2571 * U+2572 * U+2573
2021-01-01 21:01:02 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_diagonal_cross(struct buf *buf)
box-drawing: LIGHT DIAGONALs * U+2571 * U+2572 * U+2573
2021-01-01 21:01:02 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_diagonal_upper_right_to_lower_left(buf);
draw_box_drawings_light_diagonal_upper_left_to_lower_right(buf);
box-drawing: LIGHT DIAGONALs * U+2571 * U+2572 * U+2573
2021-01-01 21:01:02 +01:00
}
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_left(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(LIGHT);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_up(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(LIGHT);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_right(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(LIGHT);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_down(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(LIGHT);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_left(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_left(HEAVY);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_up(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_up(HEAVY);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_right(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
hline_middle_right(HEAVY);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_down(struct buf *buf)
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
{
box-drawing: use #defines for LIGHT and HEAVY thicknesses
2020-12-27 16:32:21 +01:00
vline_middle_down(HEAVY);
box-drawing: LIGH/HEAVY LEFT, UP, RIGTH, DOWN * U+2574 * U+2575 * U+2576 * U+2577 * U+2578 * U+2579 * U+257A * U+257B
2020-12-27 16:02:01 +01:00
}
box-drawing: mixed LIGHT/HEAVY HORIZONTAL, VERTICAL * U+257C * U+257D * U+257E * U+257F
2020-12-27 16:32:43 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_left_and_heavy_right(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY HORIZONTAL, VERTICAL * U+257C * U+257D * U+257E * U+257F
2020-12-27 16:32:43 +01:00
{
hline_middle_left(LIGHT);
hline_middle_right(HEAVY);
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_light_up_and_heavy_down(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY HORIZONTAL, VERTICAL * U+257C * U+257D * U+257E * U+257F
2020-12-27 16:32:43 +01:00
{
vline_middle_up(LIGHT);
vline_middle_down(HEAVY);
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_left_and_light_right(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY HORIZONTAL, VERTICAL * U+257C * U+257D * U+257E * U+257F
2020-12-27 16:32:43 +01:00
{
hline_middle_left(HEAVY);
hline_middle_right(LIGHT);
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_box_drawings_heavy_up_and_light_down(struct buf *buf)
box-drawing: mixed LIGHT/HEAVY HORIZONTAL, VERTICAL * U+257C * U+257D * U+257E * U+257F
2020-12-27 16:32:43 +01:00
{
vline_middle_up(HEAVY);
vline_middle_down(LIGHT);
}
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_upper_half_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, buf->width, round(buf->height / 2.));
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_lower_one_eighth_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, buf->height - round(buf->height / 8.), buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_lower_one_quarter_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, buf->height - round(buf->height / 4.), buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_lower_three_eighths_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, buf->height - round(3. * buf->height / 8.), buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_lower_half_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, buf->height - round(buf->height / 2.), buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_lower_five_eighths_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, buf->height - round(5. * buf->height / 8.), buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_lower_three_quarters_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, buf->height - round(3. * buf->height / 4.), buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_lower_seven_eighths_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, buf->height - round(7. * buf->height / 8.), buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
static void
draw_upper_one_quarter_block(struct buf *buf)
{
rect(0, 0, buf->width, round(buf->height / 4.));
}
static void
draw_upper_three_eighths_block(struct buf *buf)
{
rect(0, 0, buf->width, round(3. * buf->height / 8.));
}
static void
draw_upper_five_eighths_block(struct buf *buf)
{
rect(0, 0, buf->width, round(5. * buf->height / 8.));
}
static void
draw_upper_three_quarters_block(struct buf *buf)
{
rect(0, 0, buf->width, round(3. * buf->height / 4.));
}
static void
draw_upper_seven_eighths_block(struct buf *buf)
{
rect(0, 0, buf->width, round(7. * buf->height / 8.));
}
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_full_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, buf->width, buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_left_seven_eighths_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, round(7. * buf->width / 8.), buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_left_three_quarters_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, round(3. * buf->width / 4.), buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_left_five_eighths_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, round(5. * buf->width / 8.), buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_left_half_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, round(buf->width / 2.), buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_left_three_eighths_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, round(3. * buf->width / 8.), buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_left_one_quarter_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(0, 0, round(buf->width / 4.), buf->height);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
static void
draw_vertical_one_eighth_block_n(struct buf *buf, int n)
{
double x = round((double)n * buf->width / 8.);
double w = round(buf->width / 8.);
rect(x, 0, x + w, buf->height);
}
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_left_one_eighth_block(struct buf *buf)
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
{
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
draw_vertical_one_eighth_block_n(buf, 0);
}
static void
draw_vertical_one_eighth_block_2(struct buf *buf)
{
draw_vertical_one_eighth_block_n(buf, 1);
}
static void
draw_vertical_one_eighth_block_3(struct buf *buf)
{
draw_vertical_one_eighth_block_n(buf, 2);
}
static void
draw_vertical_one_eighth_block_4(struct buf *buf)
{
draw_vertical_one_eighth_block_n(buf, 3);
}
static void
draw_vertical_one_eighth_block_5(struct buf *buf)
{
draw_vertical_one_eighth_block_n(buf, 4);
}
static void
draw_vertical_one_eighth_block_6(struct buf *buf)
{
draw_vertical_one_eighth_block_n(buf, 5);
}
static void
draw_vertical_one_eighth_block_7(struct buf *buf)
{
draw_vertical_one_eighth_block_n(buf, 6);
box-drawing: first half of the block elements, U+2580-U+258F
2020-12-27 17:11:49 +01:00
}
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_right_half_block(struct buf *buf)
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(round(buf->width / 2.), 0, buf->width, buf->height);
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
}
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_light_shade(struct buf *buf)
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
for (size_t row = 0; row < buf->height; row += 2) {
for (size_t col = 0; col < buf->width; col += 2) {
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
size_t idx = col / 8;
size_t bit_no = col % 8;
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
buf->data[row * buf->stride + idx] |= 1 << bit_no;
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
}
}
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_medium_shade(struct buf *buf)
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
for (size_t row = 0; row < buf->height; row++) {
for (size_t col = row % 2; col < buf->width; col += 2) {
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
size_t idx = col / 8;
size_t bit_no = col % 8;
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
buf->data[row * buf->stride + idx] |= 1 << bit_no;
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
}
}
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_dark_shade(struct buf *buf)
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
for (size_t row = 0; row < buf->height; row++) {
for (size_t col = 0; col < buf->width; col += 1 + row % 2) {
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
size_t idx = col / 8;
size_t bit_no = col % 8;
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
buf->data[row * buf->stride + idx] |= 1 << bit_no;
box-drawing: LIGHT/MEDIUM/DARK SHADE * U+2591 * U+2592 * U+2593
2020-12-28 12:50:28 +01:00
}
}
}
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
static void
draw_horizontal_one_eighth_block_n(struct buf *buf, int n)
{
double y = round((double)n * buf->height / 8.);
double h = round(buf->height / 8.);
rect(0, y, buf->width, y + h);
}
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_upper_one_eighth_block(struct buf *buf)
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
{
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
draw_horizontal_one_eighth_block_n(buf, 0);
}
static void
draw_horizontal_one_eighth_block_2(struct buf *buf)
{
draw_horizontal_one_eighth_block_n(buf, 1);
}
static void
draw_horizontal_one_eighth_block_3(struct buf *buf)
{
draw_horizontal_one_eighth_block_n(buf, 2);
}
static void
draw_horizontal_one_eighth_block_4(struct buf *buf)
{
draw_horizontal_one_eighth_block_n(buf, 3);
}
static void
draw_horizontal_one_eighth_block_5(struct buf *buf)
{
draw_horizontal_one_eighth_block_n(buf, 4);
}
static void
draw_horizontal_one_eighth_block_6(struct buf *buf)
{
draw_horizontal_one_eighth_block_n(buf, 5);
}
static void
draw_horizontal_one_eighth_block_7(struct buf *buf)
{
draw_horizontal_one_eighth_block_n(buf, 6);
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_right_one_eighth_block(struct buf *buf)
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
{
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
rect(buf->width - round(buf->width / 8.), 0, buf->width, buf->height);
box-drawing: RIGHT HALF, UPPER ONE EIGHTH and RIGHT ONE EIGTH * U+2590 * U+2594 * U+2595
2020-12-27 18:42:23 +01:00
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_left(struct buf *buf)
{
rect(0, 0, ceil(buf->width / 2.), ceil(buf->height / 2.));
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_right(struct buf *buf)
{
rect(floor(buf->width / 2.), 0, buf->width, ceil(buf->height / 2.));
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_lower_left(struct buf *buf)
{
rect(0, floor(buf->height / 2.), ceil(buf->width / 2.), buf->height);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_lower_right(struct buf *buf)
{
rect(floor(buf->width / 2.), floor(buf->height / 2.), buf->width, buf->height);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_lower_left(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_lower_left(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_lower_right(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_lower_right(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_left(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_left(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_left_and_lower_left_and_lower_right(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_left(buf);
quad_lower_left(buf);
quad_lower_right(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_left_and_lower_right(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_left(buf);
quad_lower_right(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_left_and_upper_right_and_lower_left(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_left(buf);
quad_upper_right(buf);
quad_lower_left(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_left_and_upper_right_and_lower_right(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_left(buf);
quad_upper_right(buf);
quad_lower_right(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_right(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_right(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_right_and_lower_left(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_right(buf);
quad_lower_left(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_quadrant_upper_right_and_lower_left_and_lower_right(struct buf *buf)
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
{
box-drawing: quadrants: convert quad_*() macros to functions This reduces the size of the foot binary by ~4K; all the quad macros called ceil() and floor() twice per macro, which caused many float -> int -> float conversions in the expanded code. By using functions instead, there’s no expansion - the conversion only happens in one (well, four) places.
2021-01-01 21:56:53 +01:00
quad_upper_right(buf);
quad_lower_left(buf);
quad_lower_right(buf);
box-drawing: QUADRANTs * U+2596 * U+2597 * U+2598 * U+2599 * U+259A * U+259B * U+259C * U+259D * U+259E * U+259F
2020-12-27 18:43:11 +01:00
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_upper_left(struct buf *buf)
{
rect(0, 0, round(buf->width / 2.), round(buf->height / 3.));
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_middle_left(struct buf *buf)
{
rect(0, buf->height / 3, round(buf->width / 2.), round(2. * buf->height / 3.));
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_lower_left(struct buf *buf)
{
rect(0, 2 * buf->height / 3, round(buf->width / 2.), buf->height);
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_upper_right(struct buf *buf)
{
rect(buf->width / 2, 0, buf->width, round(buf->height / 3.));
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_middle_right(struct buf *buf)
{
rect(buf->width / 2, buf->height / 3, buf->width, round(2. * buf->height / 3.));
}
box-drawing: do not inline any of the utility functions
2021-01-01 22:29:26 +01:00
static void NOINLINE
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_lower_right(struct buf *buf)
{
rect(buf->width / 2, 2 * buf->height / 3, buf->width, buf->height);
}
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_sextant(wchar_t wc, struct buf *buf)
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
{
/*
* Each byte encodes one sextant:
*
* Bit sextant
* 0 upper left
* 1 middle left
* 2 lower left
* 3 upper right
* 4 middle right
* 5 lower right
*/
box-drawing: use enum constants in draw_sextant() instead of #define Both are functionally equivalent here, but the former is also properly scoped, can be naturally indented and has a less repetitive syntax.
2021-01-15 16:07:51 +00:00
enum {
UPPER_LEFT = 1 << 0,
MIDDLE_LEFT = 1 << 1,
LOWER_LEFT = 1 << 2,
UPPER_RIGHT = 1 << 3,
MIDDLE_RIGHT = 1 << 4,
LOWER_RIGHT = 1 << 5,
};
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
static const uint8_t matrix[60] = {
/* U+1fb00 - U+1fb0f */
UPPER_LEFT,
UPPER_RIGHT,
UPPER_LEFT | UPPER_RIGHT,
MIDDLE_LEFT,
UPPER_LEFT | MIDDLE_LEFT,
UPPER_RIGHT | MIDDLE_LEFT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_LEFT,
MIDDLE_RIGHT,
UPPER_LEFT | MIDDLE_RIGHT,
UPPER_RIGHT | MIDDLE_RIGHT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_RIGHT,
MIDDLE_LEFT | MIDDLE_RIGHT,
UPPER_LEFT | MIDDLE_LEFT | MIDDLE_RIGHT,
UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT,
LOWER_LEFT,
/* U+1fb10 - U+1fb1f */
UPPER_LEFT | LOWER_LEFT,
UPPER_RIGHT | LOWER_LEFT,
UPPER_LEFT | UPPER_RIGHT | LOWER_LEFT,
MIDDLE_LEFT | LOWER_LEFT,
UPPER_RIGHT | MIDDLE_LEFT | LOWER_LEFT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_LEFT | LOWER_LEFT,
MIDDLE_RIGHT | LOWER_LEFT,
UPPER_LEFT | MIDDLE_RIGHT | LOWER_LEFT,
UPPER_RIGHT | MIDDLE_RIGHT | LOWER_LEFT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_RIGHT | LOWER_LEFT,
MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT,
UPPER_LEFT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT,
UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT,
LOWER_RIGHT,
UPPER_LEFT | LOWER_RIGHT,
/* U+1fb20 - U+1fb2f */
UPPER_RIGHT | LOWER_RIGHT,
UPPER_LEFT | UPPER_RIGHT | LOWER_RIGHT,
MIDDLE_LEFT | LOWER_RIGHT,
UPPER_LEFT | MIDDLE_LEFT | LOWER_RIGHT,
UPPER_RIGHT | MIDDLE_LEFT | LOWER_RIGHT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_LEFT | LOWER_RIGHT,
MIDDLE_RIGHT | LOWER_RIGHT,
UPPER_LEFT | MIDDLE_RIGHT | LOWER_RIGHT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_RIGHT | LOWER_RIGHT,
MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_RIGHT,
UPPER_LEFT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_RIGHT,
UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_RIGHT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_RIGHT,
LOWER_LEFT | LOWER_RIGHT,
UPPER_LEFT | LOWER_LEFT | LOWER_RIGHT,
UPPER_RIGHT | LOWER_LEFT | LOWER_RIGHT,
/* U+1fb30 - U+1fb3b */
UPPER_LEFT | UPPER_RIGHT | LOWER_LEFT | LOWER_RIGHT,
MIDDLE_LEFT | LOWER_LEFT | LOWER_RIGHT,
UPPER_LEFT | MIDDLE_LEFT | LOWER_LEFT | LOWER_RIGHT,
UPPER_RIGHT | MIDDLE_LEFT | LOWER_LEFT | LOWER_RIGHT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_LEFT | LOWER_LEFT | LOWER_RIGHT,
MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
UPPER_LEFT | MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
UPPER_RIGHT | MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
UPPER_LEFT | UPPER_RIGHT | MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
UPPER_LEFT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
UPPER_RIGHT | MIDDLE_LEFT | MIDDLE_RIGHT | LOWER_LEFT | LOWER_RIGHT,
};
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(wc >= 0x1fb00 && wc <= 0x1fb3b);
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
const size_t idx = wc - 0x1fb00;
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(idx < ALEN(matrix));
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
uint8_t encoded = matrix[idx];
if (encoded & UPPER_LEFT)
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_upper_left(buf);
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
if (encoded & MIDDLE_LEFT)
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_middle_left(buf);
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
if (encoded & LOWER_LEFT)
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_lower_left(buf);
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
if (encoded & UPPER_RIGHT)
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_upper_right(buf);
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
if (encoded & MIDDLE_RIGHT)
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_middle_right(buf);
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
if (encoded & LOWER_RIGHT)
box-drawing: sextants: convert sextant_*() macros to functions While this doesn’t really reduce foot’s size, it is cleaner
2021-01-01 22:01:09 +01:00
sextant_lower_right(buf);
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
}
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
static void
draw_left_and_lower_one_eighth_block(struct buf *buf)
{
draw_left_one_eighth_block(buf);
draw_lower_one_eighth_block(buf);
}
static void
draw_left_and_upper_one_eighth_block(struct buf *buf)
{
draw_left_one_eighth_block(buf);
draw_upper_one_eighth_block(buf);
}
static void
draw_right_and_upper_one_eighth_block(struct buf *buf)
{
draw_right_one_eighth_block(buf);
draw_upper_one_eighth_block(buf);
}
static void
draw_right_and_lower_one_eighth_block(struct buf *buf)
{
draw_right_one_eighth_block(buf);
draw_lower_one_eighth_block(buf);
}
static void
draw_upper_and_lower_one_eighth_block(struct buf *buf)
{
draw_upper_one_eighth_block(buf);
draw_lower_one_eighth_block(buf);
}
static void
draw_horizontal_one_eighth_1358_block(struct buf *buf)
{
draw_upper_one_eighth_block(buf);
draw_horizontal_one_eighth_block_3(buf);
draw_horizontal_one_eighth_block_5(buf);
draw_lower_one_eighth_block(buf);
}
static void
draw_right_one_quarter_block(struct buf *buf)
{
rect(buf->width - round(buf->width / 4.), 0, buf->width, buf->height);
}
static void
draw_right_three_eighths_block(struct buf *buf)
{
rect(buf->width - round(3. * buf->width / 8.), 0, buf->width, buf->height);
}
static void
draw_right_five_eighths_block(struct buf *buf)
{
rect(buf->width - round(5. * buf->width / 8.), 0, buf->width, buf->height);
}
static void
draw_right_three_quarters_block(struct buf *buf)
{
rect(buf->width - round(3. * buf->width / 4.), 0, buf->width, buf->height);
}
static void
draw_right_seven_eighths_block(struct buf *buf)
{
rect(buf->width - round(7. * buf->width / 8.), 0, buf->width, buf->height);
}
box-drawing: initial set of LIGHT box drawings * 2500 * 2502 * 250c * 2510 * 2514 * 2518 * 251c * 2524 * 252c * 2534 * 253c
2020-12-26 18:47:55 +01:00
static void
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_glyph(wchar_t wc, struct buf *buf)
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
{
Use wrappers from macros.h instead of bare GCC attributes/pragmas
2021-01-03 08:56:47 +00:00
IGNORE_WARNING("-Wpedantic")
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
switch (wc) {
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
case 0x2500: draw_box_drawings_light_horizontal(buf); break;
case 0x2501: draw_box_drawings_heavy_horizontal(buf); break;
case 0x2502: draw_box_drawings_light_vertical(buf); break;
case 0x2503: draw_box_drawings_heavy_vertical(buf); break;
case 0x2504: draw_box_drawings_light_triple_dash_horizontal(buf); break;
case 0x2505: draw_box_drawings_heavy_triple_dash_horizontal(buf); break;
case 0x2506: draw_box_drawings_light_triple_dash_vertical(buf); break;
case 0x2507: draw_box_drawings_heavy_triple_dash_vertical(buf); break;
case 0x2508: draw_box_drawings_light_quadruple_dash_horizontal(buf); break;
case 0x2509: draw_box_drawings_heavy_quadruple_dash_horizontal(buf); break;
case 0x250a: draw_box_drawings_light_quadruple_dash_vertical(buf); break;
case 0x250b: draw_box_drawings_heavy_quadruple_dash_vertical(buf); break;
case 0x250c: draw_box_drawings_light_down_and_right(buf); break;
case 0x250d: draw_box_drawings_down_light_and_right_heavy(buf); break;
case 0x250e: draw_box_drawings_down_heavy_and_right_light(buf); break;
case 0x250f: draw_box_drawings_heavy_down_and_right(buf); break;
case 0x2510: draw_box_drawings_light_down_and_left(buf); break;
case 0x2511: draw_box_drawings_down_light_and_left_heavy(buf); break;
case 0x2512: draw_box_drawings_down_heavy_and_left_light(buf); break;
case 0x2513: draw_box_drawings_heavy_down_and_left(buf); break;
case 0x2514: draw_box_drawings_light_up_and_right(buf); break;
case 0x2515: draw_box_drawings_up_light_and_right_heavy(buf); break;
case 0x2516: draw_box_drawings_up_heavy_and_right_light(buf); break;
case 0x2517: draw_box_drawings_heavy_up_and_right(buf); break;
case 0x2518: draw_box_drawings_light_up_and_left(buf); break;
case 0x2519: draw_box_drawings_up_light_and_left_heavy(buf); break;
case 0x251a: draw_box_drawings_up_heavy_and_left_light(buf); break;
case 0x251b: draw_box_drawings_heavy_up_and_left(buf); break;
case 0x251c: draw_box_drawings_light_vertical_and_right(buf); break;
case 0x251d: draw_box_drawings_vertical_light_and_right_heavy(buf); break;
case 0x251e: draw_box_drawings_up_heavy_and_right_down_light(buf); break;
case 0x251f: draw_box_drawings_down_heavy_and_right_up_light(buf); break;
case 0x2520: draw_box_drawings_vertical_heavy_and_right_light(buf); break;
case 0x2521: draw_box_drawings_down_light_and_right_up_heavy(buf); break;
case 0x2522: draw_box_drawings_up_light_and_right_down_heavy(buf); break;
case 0x2523: draw_box_drawings_heavy_vertical_and_right(buf); break;
case 0x2524: draw_box_drawings_light_vertical_and_left(buf); break;
case 0x2525: draw_box_drawings_vertical_light_and_left_heavy(buf); break;
case 0x2526: draw_box_drawings_up_heavy_and_left_down_light(buf); break;
case 0x2527: draw_box_drawings_down_heavy_and_left_up_light(buf); break;
case 0x2528: draw_box_drawings_vertical_heavy_and_left_light(buf); break;
case 0x2529: draw_box_drawings_down_light_and_left_up_heavy(buf); break;
case 0x252a: draw_box_drawings_up_light_and_left_down_heavy(buf); break;
case 0x252b: draw_box_drawings_heavy_vertical_and_left(buf); break;
case 0x252c: draw_box_drawings_light_down_and_horizontal(buf); break;
case 0x252d: draw_box_drawings_left_heavy_and_right_down_light(buf); break;
case 0x252e: draw_box_drawings_right_heavy_and_left_down_light(buf); break;
case 0x252f: draw_box_drawings_down_light_and_horizontal_heavy(buf); break;
case 0x2530: draw_box_drawings_down_heavy_and_horizontal_light(buf); break;
case 0x2531: draw_box_drawings_right_light_and_left_down_heavy(buf); break;
case 0x2532: draw_box_drawings_left_light_and_right_down_heavy(buf); break;
case 0x2533: draw_box_drawings_heavy_down_and_horizontal(buf); break;
case 0x2534: draw_box_drawings_light_up_and_horizontal(buf); break;
case 0x2535: draw_box_drawings_left_heavy_and_right_up_light(buf); break;
case 0x2536: draw_box_drawings_right_heavy_and_left_up_light(buf); break;
case 0x2537: draw_box_drawings_up_light_and_horizontal_heavy(buf); break;
case 0x2538: draw_box_drawings_up_heavy_and_horizontal_light(buf); break;
case 0x2539: draw_box_drawings_right_light_and_left_up_heavy(buf); break;
case 0x253a: draw_box_drawings_left_light_and_right_up_heavy(buf); break;
case 0x253b: draw_box_drawings_heavy_up_and_horizontal(buf); break;
case 0x253c: draw_box_drawings_light_vertical_and_horizontal(buf); break;
case 0x253d: draw_box_drawings_left_heavy_and_right_vertical_light(buf); break;
case 0x253e: draw_box_drawings_right_heavy_and_left_vertical_light(buf); break;
case 0x253f: draw_box_drawings_vertical_light_and_horizontal_heavy(buf); break;
case 0x2540: draw_box_drawings_up_heavy_and_down_horizontal_light(buf); break;
case 0x2541: draw_box_drawings_down_heavy_and_up_horizontal_light(buf); break;
case 0x2542: draw_box_drawings_vertical_heavy_and_horizontal_light(buf); break;
case 0x2543: draw_box_drawings_left_up_heavy_and_right_down_light(buf); break;
case 0x2544: draw_box_drawings_right_up_heavy_and_left_down_light(buf); break;
case 0x2545: draw_box_drawings_left_down_heavy_and_right_up_light(buf); break;
case 0x2546: draw_box_drawings_right_down_heavy_and_left_up_light(buf); break;
case 0x2547: draw_box_drawings_down_light_and_up_horizontal_heavy(buf); break;
case 0x2548: draw_box_drawings_up_light_and_down_horizontal_heavy(buf); break;
case 0x2549: draw_box_drawings_right_light_and_left_vertical_heavy(buf); break;
case 0x254a: draw_box_drawings_left_light_and_right_vertical_heavy(buf); break;
case 0x254b: draw_box_drawings_heavy_vertical_and_horizontal(buf); break;
case 0x254c: draw_box_drawings_light_double_dash_horizontal(buf); break;
case 0x254d: draw_box_drawings_heavy_double_dash_horizontal(buf); break;
case 0x254e: draw_box_drawings_light_double_dash_vertical(buf); break;
case 0x254f: draw_box_drawings_heavy_double_dash_vertical(buf); break;
case 0x2550: draw_box_drawings_double_horizontal(buf); break;
case 0x2551: draw_box_drawings_double_vertical(buf); break;
case 0x2552: draw_box_drawings_down_single_and_right_double(buf); break;
case 0x2553: draw_box_drawings_down_double_and_right_single(buf); break;
case 0x2554: draw_box_drawings_double_down_and_right(buf); break;
case 0x2555: draw_box_drawings_down_single_and_left_double(buf); break;
case 0x2556: draw_box_drawings_down_double_and_left_single(buf); break;
case 0x2557: draw_box_drawings_double_down_and_left(buf); break;
case 0x2558: draw_box_drawings_up_single_and_right_double(buf); break;
case 0x2559: draw_box_drawings_up_double_and_right_single(buf); break;
case 0x255a: draw_box_drawings_double_up_and_right(buf); break;
case 0x255b: draw_box_drawings_up_single_and_left_double(buf); break;
case 0x255c: draw_box_drawings_up_double_and_left_single(buf); break;
case 0x255d: draw_box_drawings_double_up_and_left(buf); break;
case 0x255e: draw_box_drawings_vertical_single_and_right_double(buf); break;
case 0x255f: draw_box_drawings_vertical_double_and_right_single(buf); break;
case 0x2560: draw_box_drawings_double_vertical_and_right(buf); break;
case 0x2561: draw_box_drawings_vertical_single_and_left_double(buf); break;
case 0x2562: draw_box_drawings_vertical_double_and_left_single(buf); break;
case 0x2563: draw_box_drawings_double_vertical_and_left(buf); break;
case 0x2564: draw_box_drawings_down_single_and_horizontal_double(buf); break;
case 0x2565: draw_box_drawings_down_double_and_horizontal_single(buf); break;
case 0x2566: draw_box_drawings_double_down_and_horizontal(buf); break;
case 0x2567: draw_box_drawings_up_single_and_horizontal_double(buf); break;
case 0x2568: draw_box_drawings_up_double_and_horizontal_single(buf); break;
case 0x2569: draw_box_drawings_double_up_and_horizontal(buf); break;
case 0x256a: draw_box_drawings_vertical_single_and_horizontal_double(buf); break;
case 0x256b: draw_box_drawings_vertical_double_and_horizontal_single(buf); break;
case 0x256c: draw_box_drawings_double_vertical_and_horizontal(buf); break;
case 0x256d ... 0x2570: draw_box_drawings_light_arc(wc, buf); break;
case 0x2571: draw_box_drawings_light_diagonal_upper_right_to_lower_left(buf); break;
case 0x2572: draw_box_drawings_light_diagonal_upper_left_to_lower_right(buf); break;
case 0x2573: draw_box_drawings_light_diagonal_cross(buf); break;
case 0x2574: draw_box_drawings_light_left(buf); break;
case 0x2575: draw_box_drawings_light_up(buf); break;
case 0x2576: draw_box_drawings_light_right(buf); break;
case 0x2577: draw_box_drawings_light_down(buf); break;
case 0x2578: draw_box_drawings_heavy_left(buf); break;
case 0x2579: draw_box_drawings_heavy_up(buf); break;
case 0x257a: draw_box_drawings_heavy_right(buf); break;
case 0x257b: draw_box_drawings_heavy_down(buf); break;
case 0x257c: draw_box_drawings_light_left_and_heavy_right(buf); break;
case 0x257d: draw_box_drawings_light_up_and_heavy_down(buf); break;
case 0x257e: draw_box_drawings_heavy_left_and_light_right(buf); break;
case 0x257f: draw_box_drawings_heavy_up_and_light_down(buf); break;
case 0x2580: draw_upper_half_block(buf); break;
case 0x2581: draw_lower_one_eighth_block(buf); break;
case 0x2582: draw_lower_one_quarter_block(buf); break;
case 0x2583: draw_lower_three_eighths_block(buf); break;
case 0x2584: draw_lower_half_block(buf); break;
case 0x2585: draw_lower_five_eighths_block(buf); break;
case 0x2586: draw_lower_three_quarters_block(buf); break;
case 0x2587: draw_lower_seven_eighths_block(buf); break;
case 0x2588: draw_full_block(buf); break;
case 0x2589: draw_left_seven_eighths_block(buf); break;
case 0x258a: draw_left_three_quarters_block(buf); break;
case 0x258b: draw_left_five_eighths_block(buf); break;
case 0x258c: draw_left_half_block(buf); break;
case 0x258d: draw_left_three_eighths_block(buf); break;
case 0x258e: draw_left_one_quarter_block(buf); break;
case 0x258f: draw_left_one_eighth_block(buf); break;
case 0x2590: draw_right_half_block(buf); break;
case 0x2591: draw_light_shade(buf); break;
case 0x2592: draw_medium_shade(buf); break;
case 0x2593: draw_dark_shade(buf); break;
case 0x2594: draw_upper_one_eighth_block(buf); break;
case 0x2595: draw_right_one_eighth_block(buf); break;
case 0x2596: draw_quadrant_lower_left(buf); break;
case 0x2597: draw_quadrant_lower_right(buf); break;
case 0x2598: draw_quadrant_upper_left(buf); break;
case 0x2599: draw_quadrant_upper_left_and_lower_left_and_lower_right(buf); break;
case 0x259a: draw_quadrant_upper_left_and_lower_right(buf); break;
case 0x259b: draw_quadrant_upper_left_and_upper_right_and_lower_left(buf); break;
case 0x259c: draw_quadrant_upper_left_and_upper_right_and_lower_right(buf); break;
case 0x259d: draw_quadrant_upper_right(buf); break;
case 0x259e: draw_quadrant_upper_right_and_lower_left(buf); break;
case 0x259f: draw_quadrant_upper_right_and_lower_left_and_lower_right(buf); break;
case 0x1fb00 ... 0x1fb3b: draw_sextant(wc, buf); break;
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
case 0x1fb70: draw_vertical_one_eighth_block_2(buf); break;
case 0x1fb71: draw_vertical_one_eighth_block_3(buf); break;
case 0x1fb72: draw_vertical_one_eighth_block_4(buf); break;
case 0x1fb73: draw_vertical_one_eighth_block_5(buf); break;
case 0x1fb74: draw_vertical_one_eighth_block_6(buf); break;
case 0x1fb75: draw_vertical_one_eighth_block_7(buf); break;
case 0x1fb76: draw_horizontal_one_eighth_block_2(buf); break;
case 0x1fb77: draw_horizontal_one_eighth_block_3(buf); break;
case 0x1fb78: draw_horizontal_one_eighth_block_4(buf); break;
case 0x1fb79: draw_horizontal_one_eighth_block_5(buf); break;
case 0x1fb7a: draw_horizontal_one_eighth_block_6(buf); break;
case 0x1fb7b: draw_horizontal_one_eighth_block_7(buf); break;
case 0x1fb82: draw_upper_one_quarter_block(buf); break;
case 0x1fb83: draw_upper_three_eighths_block(buf); break;
case 0x1fb84: draw_upper_five_eighths_block(buf); break;
case 0x1fb85: draw_upper_three_quarters_block(buf); break;
case 0x1fb86: draw_upper_seven_eighths_block(buf); break;
case 0x1fb7c: draw_left_and_lower_one_eighth_block(buf); break;
case 0x1fb7d: draw_left_and_upper_one_eighth_block(buf); break;
case 0x1fb7e: draw_right_and_upper_one_eighth_block(buf); break;
case 0x1fb7f: draw_right_and_lower_one_eighth_block(buf); break;
case 0x1fb80: draw_upper_and_lower_one_eighth_block(buf); break;
case 0x1fb81: draw_horizontal_one_eighth_1358_block(buf); break;
case 0x1fb87: draw_right_one_quarter_block(buf); break;
case 0x1fb88: draw_right_three_eighths_block(buf); break;
case 0x1fb89: draw_right_five_eighths_block(buf); break;
case 0x1fb8a: draw_right_three_quarters_block(buf); break;
case 0x1fb8b: draw_right_seven_eighths_block(buf); break;
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
}
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
Use wrappers from macros.h instead of bare GCC attributes/pragmas
2021-01-03 08:56:47 +00:00
UNIGNORE_WARNINGS
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
}
box-drawing: oops - remove accidental ‘x’
2020-12-29 11:39:10 +01:00
struct fcft_glyph * COLD
box-drawing: make ‘term’ parameter const
2020-12-29 10:40:58 +01:00
box_drawing(const struct terminal *term, wchar_t wc)
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
{
int width = term->cell_width;
int height = term->cell_height;
box-drawing: include pixman image in the buffer we’re passing around
2021-05-05 14:59:53 +02:00
pixman_format_code_t fmt = PIXMAN_a1; /* TODO: use a8 when antialiasing=true */
int stride = stride_for_format_and_width(fmt, width);
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
uint8_t *data = xcalloc(height * stride, 1);
pixman_image_t *pix = pixman_image_create_bits_no_clear(
box-drawing: include pixman image in the buffer we’re passing around
2021-05-05 14:59:53 +02:00
fmt, width, height, (uint32_t*)data, stride);
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
if (pix == NULL) {
errno = ENOMEM;
perror(__func__);
abort();
}
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
struct buf buf = {
.data = data,
box-drawing: include pixman image in the buffer we’re passing around
2021-05-05 14:59:53 +02:00
.pix = pix,
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
.width = width,
.height = height,
.stride = stride,
.dpi = term->font_dpi,
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
.cell_size = sqrt(pow(term->cell_width, 2) + pow(term->cell_height, 2)),
.base_thickness = term->conf->tweak.box_drawing_base_thickness,
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
};
box-drawing: line thickness now depends on both DPI and cell size Cell size is defined as the length of the diagonal of the cell.
2021-01-08 10:28:01 +01:00
LOG_DBG("LIGHT=%d, HEAVY=%d",
_thickness(&buf, LIGHT), _thickness(&buf, HEAVY));
box-drawing: reduce number of function arguments We were using so many function arguments that a lot of the emitted code was just stack push and pops to pass around arguments. Bundle the buffer data, width, height, stride, and current DPI, into a single ‘buf’ argument. This greatly reduces the number of arguments to all functions.
2021-01-01 21:47:05 +01:00
draw_glyph(wc, &buf);
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
struct fcft_glyph *glyph = xmalloc(sizeof(*glyph));
*glyph = (struct fcft_glyph){
.wc = wc,
.cols = 1,
.pix = pix,
box-drawing: x/y offsets: use pre-calculated offset values from term struct
2021-01-07 17:19:43 +01:00
.x = -term->font_x_ofs,
.y = term->font_y_ofs + term->fonts[0]->ascent,
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
.width = width,
.height = height,
.advance = {
.x = width,
.y = height,
},
};
return glyph;
}
Reference in a new issue Copy permalink