| /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ |
| |
| /*** |
| This file is part of systemd. |
| |
| Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com> |
| |
| systemd is free software; you can redistribute it and/or modify it |
| under the terms of the GNU Lesser General Public License as published by |
| the Free Software Foundation; either version 2.1 of the License, or |
| (at your option) any later version. |
| |
| systemd is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with systemd; If not, see <http://www.gnu.org/licenses/>. |
| ***/ |
| |
| /* |
| * Terminal Page/Line/Cell/Char Handling |
| * This file implements page handling of a terminal. It is split into pages, |
| * lines, cells and characters. Each object is independent of the next upper |
| * object. |
| * |
| * The Terminal layer keeps each line of a terminal separate and dynamically |
| * allocated. This allows us to move lines from main-screen to history-buffers |
| * very fast. Same is true for scrolling, top/bottom borders and other buffer |
| * operations. |
| * |
| * While lines are dynamically allocated, cells are not. This would be a waste |
| * of memory and causes heavy fragmentation. Furthermore, cells are moved much |
| * less frequently than lines so the performance-penalty is pretty small. |
| * However, to support combining-characters, we have to initialize and cleanup |
| * cells properly and cannot just release the underlying memory. Therefore, |
| * cells are treated as proper objects despite being allocated in arrays. |
| * |
| * Each cell has a set of attributes and a stored character. This is usually a |
| * single Unicode character stored as 32bit UCS-4 char. However, we need to |
| * support Unicode combining-characters, therefore this gets more complicated. |
| * Characters themselves are represented by a "term_char_t" object. It |
| * should be treated as a normal integer and passed by value. The |
| * sorrounding struct is just to hide the internals. A term-char can contain a |
| * base character together with up to 2 combining-chars in a single integer. |
| * Only if you need more combining-chars (very unlikely!) a term-char is a |
| * pointer to an allocated storage. This requires you to always free term-char |
| * objects once no longer used (even though this is a no-op most of the time). |
| * Furthermore, term-char objects are not ref-counted so you must duplicate them |
| * in case you want to store it somewhere and retain a copy yourself. By |
| * convention, all functions that take a term-char object will not duplicate |
| * it but implicitly take ownership of the passed value. It's up to the caller |
| * to duplicate it beforehand, in case it wants to retain a copy. |
| * |
| * If it turns out, that more than 2 comb-chars become common in specific |
| * languages, we can try to optimize this. One idea is to ref-count allocated |
| * characters and store them in a hash-table (like gnome's libvte3 does). This |
| * way we will never have two allocated chars for the same content. Or we can |
| * simply put two uint64_t into a "term_char_t". This will slow down operations |
| * on systems that don't need that many comb-chars, but avoid the dynamic |
| * allocations on others. |
| * Anyhow, until we have proper benchmarks, we will keep the current code. It |
| * seems to compete very well with other solutions so far. |
| * |
| * The page-layer is a one-dimensional array of lines. Considering that each |
| * line is a one-dimensional array of cells, the page layer provides the |
| * two-dimensional cell-page required for terminals. The page itself only |
| * operates on lines. All cell-related operations are forwarded to the correct |
| * line. |
| * A page does not contain any cursor tracking. It only provides the raw |
| * operations to shuffle lines and modify the page. |
| */ |
| |
| #include <stdbool.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <wchar.h> |
| #include "macro.h" |
| #include "term-internal.h" |
| #include "util.h" |
| |
| /* maximum UCS-4 character */ |
| #define CHAR_UCS4_MAX (0x10ffff) |
| /* mask for valid UCS-4 characters (21bit) */ |
| #define CHAR_UCS4_MASK (0x1fffff) |
| /* UCS-4 replacement character */ |
| #define CHAR_UCS4_REPLACEMENT (0xfffd) |
| |
| /* real storage behind "term_char_t" in case it's not packed */ |
| typedef struct term_character { |
| uint8_t n; |
| uint32_t codepoints[]; |
| } term_character; |
| |
| /* |
| * char_pack() takes 3 UCS-4 values and packs them into a term_char_t object. |
| * Note that UCS-4 chars only take 21 bits, so we still have the LSB as marker. |
| * We set it to 1 so others can distinguish it from pointers. |
| */ |
| static inline term_char_t char_pack(uint32_t v1, uint32_t v2, uint32_t v3) { |
| uint64_t packed, u1, u2, u3; |
| |
| u1 = v1; |
| u2 = v2; |
| u3 = v3; |
| |
| packed = 0x01; |
| packed |= (u1 & (uint64_t)CHAR_UCS4_MASK) << 43; |
| packed |= (u2 & (uint64_t)CHAR_UCS4_MASK) << 22; |
| packed |= (u3 & (uint64_t)CHAR_UCS4_MASK) << 1; |
| |
| return TERM_CHAR_INIT(packed); |
| } |
| |
| #define char_pack1(_v1) char_pack2((_v1), CHAR_UCS4_MAX + 1) |
| #define char_pack2(_v1, _v2) char_pack3((_v1), (_v2), CHAR_UCS4_MAX + 1) |
| #define char_pack3(_v1, _v2, _v3) char_pack((_v1), (_v2), (_v3)) |
| |
| /* |
| * char_unpack() is the inverse of char_pack(). It extracts the 3 stored UCS-4 |
| * characters and returns them. Note that this does not validate the passed |
| * term_char_t. That's the responsibility of the caller. |
| * This returns the number of characters actually packed. This obviously is a |
| * number between 0 and 3 (inclusive). |
| */ |
| static inline uint8_t char_unpack(term_char_t packed, uint32_t *out_v1, uint32_t *out_v2, uint32_t *out_v3) { |
| uint32_t v1, v2, v3; |
| |
| v1 = (packed._value >> 43) & (uint64_t)CHAR_UCS4_MASK; |
| v2 = (packed._value >> 22) & (uint64_t)CHAR_UCS4_MASK; |
| v3 = (packed._value >> 1) & (uint64_t)CHAR_UCS4_MASK; |
| |
| if (out_v1) |
| *out_v1 = v1; |
| if (out_v2) |
| *out_v2 = v2; |
| if (out_v3) |
| *out_v3 = v3; |
| |
| return (v1 > CHAR_UCS4_MAX) ? 0 : |
| ((v2 > CHAR_UCS4_MAX) ? 1 : |
| ((v3 > CHAR_UCS4_MAX) ? 2 : |
| 3)); |
| } |
| |
| /* cast a term_char_t to a term_character* */ |
| static inline term_character *char_to_ptr(term_char_t ch) { |
| return (term_character*)(unsigned long)ch._value; |
| } |
| |
| /* cast a term_character* to a term_char_t */ |
| static inline term_char_t char_from_ptr(term_character *c) { |
| return TERM_CHAR_INIT((unsigned long)c); |
| } |
| |
| /* |
| * char_alloc() allocates a properly aligned term_character object and returns |
| * a pointer to it. NULL is returned on allocation errors. The object will have |
| * enough room for @n following UCS-4 chars. |
| * Note that we allocate (n+1) characters and set the last one to 0 in case |
| * anyone prints this string for debugging. |
| */ |
| static term_character *char_alloc(uint8_t n) { |
| term_character *c; |
| int r; |
| |
| r = posix_memalign((void**)&c, |
| MAX(sizeof(void*), (size_t)2), |
| sizeof(*c) + sizeof(*c->codepoints) * (n + 1)); |
| if (r) |
| return NULL; |
| |
| c->n = n; |
| c->codepoints[n] = 0; |
| |
| return c; |
| } |
| |
| /* |
| * char_free() frees the memory allocated via char_alloc(). It is safe to call |
| * this on any term_char_t, only allocated characters are freed. |
| */ |
| static inline void char_free(term_char_t ch) { |
| if (term_char_is_allocated(ch)) |
| free(char_to_ptr(ch)); |
| } |
| |
| /* |
| * This appends @append_ucs4 to the existing character @base and returns |
| * it as a new character. In case that's not possible, @base is returned. The |
| * caller can use term_char_same() to test whether the returned character was |
| * freshly allocated or not. |
| */ |
| static term_char_t char_build(term_char_t base, uint32_t append_ucs4) { |
| /* soft-limit for combining-chars; hard-limit is currently 255 */ |
| const size_t climit = 64; |
| term_character *c; |
| uint32_t buf[3], *t; |
| uint8_t n; |
| |
| /* ignore invalid UCS-4 */ |
| if (append_ucs4 > CHAR_UCS4_MAX) |
| return base; |
| |
| if (term_char_is_null(base)) { |
| return char_pack1(append_ucs4); |
| } else if (!term_char_is_allocated(base)) { |
| /* unpack and try extending the packed character */ |
| n = char_unpack(base, &buf[0], &buf[1], &buf[2]); |
| |
| switch (n) { |
| case 0: |
| return char_pack1(append_ucs4); |
| case 1: |
| if (climit < 2) |
| return base; |
| |
| return char_pack2(buf[0], append_ucs4); |
| case 2: |
| if (climit < 3) |
| return base; |
| |
| return char_pack3(buf[0], buf[1], append_ucs4); |
| default: |
| /* fallthrough */ |
| break; |
| } |
| |
| /* already fully packed, we need to allocate a new one */ |
| t = buf; |
| } else { |
| /* already an allocated type, we need to allocate a new one */ |
| c = char_to_ptr(base); |
| t = c->codepoints; |
| n = c->n; |
| } |
| |
| /* bail out if soft-limit is reached */ |
| if (n >= climit) |
| return base; |
| |
| /* allocate new char */ |
| c = char_alloc(n + 1); |
| if (!c) |
| return base; |
| |
| memcpy(c->codepoints, t, sizeof(*t) * n); |
| c->codepoints[n] = append_ucs4; |
| |
| return char_from_ptr(c); |
| } |
| |
| /** |
| * term_char_set() - Reset character to a single UCS-4 character |
| * @previous: term-char to reset |
| * @append_ucs4: UCS-4 char to set |
| * |
| * This frees all resources in @previous and re-initializes it to @append_ucs4. |
| * The new char is returned. |
| * |
| * Usually, this is used like this: |
| * obj->ch = term_char_set(obj->ch, ucs4); |
| * |
| * Returns: The previous character reset to @append_ucs4. |
| */ |
| term_char_t term_char_set(term_char_t previous, uint32_t append_ucs4) { |
| char_free(previous); |
| return char_build(TERM_CHAR_NULL, append_ucs4); |
| } |
| |
| /** |
| * term_char_merge() - Merge UCS-4 char at the end of an existing char |
| * @base: existing term-char |
| * @append_ucs4: UCS-4 character to append |
| * |
| * This appends @append_ucs4 to @base and returns the result. @base is |
| * invalidated by this function and must no longer be used. The returned value |
| * replaces the old one. |
| * |
| * Usually, this is used like this: |
| * obj->ch = term_char_merge(obj->ch, ucs4); |
| * |
| * Returns: The new merged character. |
| */ |
| term_char_t term_char_merge(term_char_t base, uint32_t append_ucs4) { |
| term_char_t ch; |
| |
| ch = char_build(base, append_ucs4); |
| if (!term_char_same(ch, base)) |
| term_char_free(base); |
| |
| return ch; |
| } |
| |
| /** |
| * term_char_dup() - Duplicate character |
| * @ch: character to duplicate |
| * |
| * This duplicates a term-character. In case the character is not allocated, |
| * nothing is done. Otherwise, the underlying memory is copied and returned. You |
| * need to call term_char_free() on the returned character to release it again. |
| * On allocation errors, a replacement character is returned. Therefore, the |
| * caller can safely assume that this function always succeeds. |
| * |
| * Returns: The duplicated term-character. |
| */ |
| term_char_t term_char_dup(term_char_t ch) { |
| term_character *c, *newc; |
| |
| if (!term_char_is_allocated(ch)) |
| return ch; |
| |
| c = char_to_ptr(ch); |
| newc = char_alloc(c->n); |
| if (!newc) |
| return char_pack1(CHAR_UCS4_REPLACEMENT); |
| |
| memcpy(newc->codepoints, c->codepoints, sizeof(*c->codepoints) * c->n); |
| return char_from_ptr(newc); |
| } |
| |
| /** |
| * term_char_dup_append() - Duplicate tsm-char with UCS-4 character appended |
| * @base: existing term-char |
| * @append_ucs4: UCS-4 character to append |
| * |
| * This is similar to term_char_merge(), but it returns a separately allocated |
| * character. That is, @base will stay valid after this returns and is not |
| * touched. In case the append-operation fails, @base is duplicated and |
| * returned. That is, the returned char is always independent of @base. |
| * |
| * Returns: Newly allocated character with @append_ucs4 appended to @base. |
| */ |
| term_char_t term_char_dup_append(term_char_t base, uint32_t append_ucs4) { |
| term_char_t ch; |
| |
| ch = char_build(base, append_ucs4); |
| if (term_char_same(ch, base)) |
| ch = term_char_dup(base); |
| |
| return ch; |
| } |
| |
| /** |
| * term_char_resolve() - Retrieve the UCS-4 string for a term-char |
| * @ch: character to resolve |
| * @s: storage for size of string or NULL |
| * @b: storage for string or NULL |
| * |
| * This takes a term-character and returns the UCS-4 string associated with it. |
| * In case @ch is not allocated, the string is stored in @b (in case @b is NULL |
| * static storage is used). Otherwise, a pointer to the allocated storage is |
| * returned. |
| * |
| * The returned string is only valid as long as @ch and @b are valid. The string |
| * is zero-terminated and can safely be printed via long-character printf(). |
| * The length of the string excluding the zero-character is returned in @s. |
| * |
| * This never returns NULL. Even if the size is 0, this points to a buffer of at |
| * least a zero-terminator. |
| * |
| * Returns: The UCS-4 string-representation of @ch, and its size in @s. |
| */ |
| const uint32_t *term_char_resolve(term_char_t ch, size_t *s, term_charbuf_t *b) { |
| static term_charbuf_t static_b; |
| term_character *c; |
| uint32_t *cache; |
| size_t len; |
| |
| if (b) |
| cache = b->buf; |
| else |
| cache = static_b.buf; |
| |
| if (term_char_is_null(ch)) { |
| len = 0; |
| cache[0] = 0; |
| } else if (term_char_is_allocated(ch)) { |
| c = char_to_ptr(ch); |
| len = c->n; |
| cache = c->codepoints; |
| } else { |
| len = char_unpack(ch, &cache[0], &cache[1], &cache[2]); |
| cache[len] = 0; |
| } |
| |
| if (s) |
| *s = len; |
| |
| return cache; |
| } |
| |
| /** |
| * term_char_lookup_width() - Lookup cell-width of a character |
| * @ch: character to return cell-width for |
| * |
| * This is an equivalent of wcwidth() for term_char_t. It can deal directly |
| * with UCS-4 and combining-characters and avoids the mess that is wchar_t and |
| * locale handling. |
| * |
| * Returns: 0 for unprintable characters, >0 for everything else. |
| */ |
| unsigned int term_char_lookup_width(term_char_t ch) { |
| term_charbuf_t b; |
| const uint32_t *str; |
| unsigned int max; |
| size_t i, len; |
| int r; |
| |
| max = 0; |
| str = term_char_resolve(ch, &len, &b); |
| |
| for (i = 0; i < len; ++i) { |
| /* |
| * Oh god, C99 locale handling strikes again: wcwidth() expects |
| * wchar_t, but there is no way for us to know the |
| * internal encoding of wchar_t. Moreover, it is nearly |
| * impossible to convert UCS-4 into wchar_t (except for iconv, |
| * which is way too much overhead). |
| * Therefore, we use our own copy of wcwidth(). Lets just hope |
| * that glibc will one day export it's internal UCS-4 and UTF-8 |
| * helpers for direct use. |
| */ |
| assert_cc(sizeof(wchar_t) >= 4); |
| r = mk_wcwidth((wchar_t)str[i]); |
| if (r > 0 && (unsigned int)r > max) |
| max = r; |
| } |
| |
| return max; |
| } |
| |
| /** |
| * term_cell_init() - Initialize a new cell |
| * @cell: cell to initialize |
| * @ch: character to set on the cell or TERM_CHAR_NULL |
| * @cwidth: character width of @ch |
| * @attr: attributes to set on the cell or NULL |
| * @age: age to set on the cell or TERM_AGE_NULL |
| * |
| * This initializes a new cell. The backing-memory of the cell must be allocated |
| * by the caller beforehand. The caller is responsible to destroy the cell via |
| * term_cell_destroy() before freeing the backing-memory. |
| * |
| * It is safe (and supported!) to use: |
| * zero(*c); |
| * instead of: |
| * term_cell_init(c, TERM_CHAR_NULL, NULL, TERM_AGE_NULL); |
| * |
| * Note that this call takes ownership of @ch. If you want to use it yourself |
| * after this call, you need to duplicate it before calling this. |
| */ |
| static void term_cell_init(term_cell *cell, term_char_t ch, unsigned int cwidth, const term_attr *attr, term_age_t age) { |
| assert(cell); |
| |
| cell->ch = ch; |
| cell->cwidth = cwidth; |
| cell->age = age; |
| |
| if (attr) |
| memcpy(&cell->attr, attr, sizeof(*attr)); |
| else |
| zero(cell->attr); |
| } |
| |
| /** |
| * term_cell_destroy() - Destroy previously initialized cell |
| * @cell: cell to destroy or NULL |
| * |
| * This releases all resources associated with a cell. The backing memory is |
| * kept as-is. It's the responsibility of the caller to manage it. |
| * |
| * You must not call any other cell operations on this cell after this call |
| * returns. You must re-initialize the cell via term_cell_init() before you can |
| * use it again. |
| * |
| * If @cell is NULL, this is a no-op. |
| */ |
| static void term_cell_destroy(term_cell *cell) { |
| if (!cell) |
| return; |
| |
| term_char_free(cell->ch); |
| } |
| |
| /** |
| * term_cell_set() - Change contents of a cell |
| * @cell: cell to modify |
| * @ch: character to set on the cell or cell->ch |
| * @cwidth: character width of @ch or cell->cwidth |
| * @attr: attributes to set on the cell or NULL |
| * @age: age to set on the cell or cell->age |
| * |
| * This changes the contents of a cell. It can be used to change the character, |
| * attributes and age. To keep the current character, pass cell->ch as @ch. To |
| * reset the current attributes, pass NULL. To keep the current age, pass |
| * cell->age. |
| * |
| * This call takes ownership of @ch. You need to duplicate it first, in case you |
| * want to use it for your own purposes after this call. |
| * |
| * The cell must have been initialized properly before calling this. See |
| * term_cell_init(). |
| */ |
| static void term_cell_set(term_cell *cell, term_char_t ch, unsigned int cwidth, const term_attr *attr, term_age_t age) { |
| assert(cell); |
| |
| if (!term_char_same(ch, cell->ch)) { |
| term_char_free(cell->ch); |
| cell->ch = ch; |
| } |
| |
| cell->cwidth = cwidth; |
| cell->age = age; |
| |
| if (attr) |
| memcpy(&cell->attr, attr, sizeof(*attr)); |
| else |
| zero(cell->attr); |
| } |
| |
| /** |
| * term_cell_append() - Append a combining-char to a cell |
| * @cell: cell to modify |
| * @ucs4: UCS-4 character to append to the cell |
| * @age: new age to set on the cell or cell->age |
| * |
| * This appends a combining-character to a cell. No validation of the UCS-4 |
| * character is done, so this can be used to append any character. Additionally, |
| * this can update the age of the cell. |
| * |
| * The cell must have been initialized properly before calling this. See |
| * term_cell_init(). |
| */ |
| static void term_cell_append(term_cell *cell, uint32_t ucs4, term_age_t age) { |
| assert(cell); |
| |
| cell->ch = term_char_merge(cell->ch, ucs4); |
| cell->age = age; |
| } |
| |
| /** |
| * term_cell_init_n() - Initialize an array of cells |
| * @cells: pointer to an array of cells to initialize |
| * @n: number of cells |
| * @attr: attributes to set on all cells or NULL |
| * @age: age to set on all cells |
| * |
| * This is the same as term_cell_init() but initializes an array of cells. |
| * Furthermore, this always sets the character to TERM_CHAR_NULL. |
| * If you want to set a specific characters on all cells, you need to hard-code |
| * this loop and duplicate the character for each cell. |
| */ |
| static void term_cell_init_n(term_cell *cells, unsigned int n, const term_attr *attr, term_age_t age) { |
| for ( ; n > 0; --n, ++cells) |
| term_cell_init(cells, TERM_CHAR_NULL, 0, attr, age); |
| } |
| |
| /** |
| * term_cell_destroy_n() - Destroy an array of cells |
| * @cells: pointer to an array of cells to destroy |
| * @n: number of cells |
| * |
| * This is the same as term_cell_destroy() but destroys an array of cells. |
| */ |
| static void term_cell_destroy_n(term_cell *cells, unsigned int n) { |
| for ( ; n > 0; --n, ++cells) |
| term_cell_destroy(cells); |
| } |
| |
| /** |
| * term_cell_clear_n() - Clear contents of an array of cells |
| * @cells: pointer to an array of cells to modify |
| * @n: number of cells |
| * @attr: attributes to set on all cells or NULL |
| * @age: age to set on all cells |
| * |
| * This is the same as term_cell_set() but operates on an array of cells. Note |
| * that all characters are always set to TERM_CHAR_NULL, unlike term_cell_set() |
| * which takes the character as argument. |
| * If you want to set a specific characters on all cells, you need to hard-code |
| * this loop and duplicate the character for each cell. |
| */ |
| static void term_cell_clear_n(term_cell *cells, unsigned int n, const term_attr *attr, term_age_t age) { |
| for ( ; n > 0; --n, ++cells) |
| term_cell_set(cells, TERM_CHAR_NULL, 0, attr, age); |
| } |
| |
| /** |
| * term_line_new() - Allocate a new line |
| * @out: place to store pointer to new line |
| * |
| * This allocates and initialized a new line. The line is unlinked and |
| * independent of any page. It can be used for any purpose. The initial |
| * cell-count is set to 0. |
| * |
| * The line has to be freed via term_line_free() once it's no longer needed. |
| * |
| * Returns: 0 on success, negative error code on failure. |
| */ |
| int term_line_new(term_line **out) { |
| _term_line_free_ term_line *line = NULL; |
| |
| assert_return(out, -EINVAL); |
| |
| line = new0(term_line, 1); |
| if (!line) |
| return -ENOMEM; |
| |
| *out = line; |
| line = NULL; |
| return 0; |
| } |
| |
| /** |
| * term_line_free() - Free a line |
| * @line: line to free or NULL |
| * |
| * This frees a line that was previously allocated via term_line_free(). All its |
| * cells are released, too. |
| * |
| * If @line is NULL, this is a no-op. |
| */ |
| term_line *term_line_free(term_line *line) { |
| if (!line) |
| return NULL; |
| |
| term_cell_destroy_n(line->cells, line->n_cells); |
| free(line->cells); |
| free(line); |
| |
| return NULL; |
| } |
| |
| /** |
| * term_line_reserve() - Pre-allocate cells for a line |
| * @line: line to pre-allocate cells for |
| * @width: numbers of cells the line shall have pre-allocated |
| * @attr: attribute for all allocated cells or NULL |
| * @age: current age for all modifications |
| * @protect_width: width to protect from erasure |
| * |
| * This pre-allocates cells for this line. Please note that @width is the number |
| * of cells the line is guaranteed to have allocated after this call returns. |
| * It's not the number of cells that are added, neither is it the new width of |
| * the line. |
| * |
| * This function never frees memory. That is, reducing the line-width will |
| * always succeed, same is true for increasing the width to a previously set |
| * width. |
| * |
| * @attr and @age are used to initialize new cells. Additionally, any |
| * existing cell outside of the protected area specified by @protect_width are |
| * cleared and reset with @attr and @age. |
| * |
| * Returns: 0 on success, negative error code on failure. |
| */ |
| int term_line_reserve(term_line *line, unsigned int width, const term_attr *attr, term_age_t age, unsigned int protect_width) { |
| unsigned int min_width; |
| term_cell *t; |
| |
| assert_return(line, -EINVAL); |
| |
| /* reset existing cells if required */ |
| min_width = MIN(line->n_cells, width); |
| if (min_width > protect_width) |
| term_cell_clear_n(line->cells + protect_width, |
| min_width - protect_width, |
| attr, |
| age); |
| |
| /* allocate new cells if required */ |
| |
| if (width > line->n_cells) { |
| t = realloc_multiply(line->cells, sizeof(*t), width); |
| if (!t) |
| return -ENOMEM; |
| |
| if (!attr && !age) |
| memzero(t + line->n_cells, |
| sizeof(*t) * (width - line->n_cells)); |
| else |
| term_cell_init_n(t + line->n_cells, |
| width - line->n_cells, |
| attr, |
| age); |
| |
| line->cells = t; |
| line->n_cells = width; |
| } |
| |
| line->fill = MIN(line->fill, protect_width); |
| |
| return 0; |
| } |
| |
| /** |
| * term_line_set_width() - Change width of a line |
| * @line: line to modify |
| * @width: new width |
| * |
| * This changes the actual width of a line. It is the caller's responsibility |
| * to use term_line_reserve() to make sure enough space is allocated. If @width |
| * is greater than the allocated size, it is cropped. |
| * |
| * This does not modify any cells. Use term_line_reserve() or term_line_erase() |
| * to clear any newly added cells. |
| * |
| * NOTE: The fill state is cropped at line->width. Therefore, if you increase |
| * the line-width afterwards, but there is a multi-cell character at the |
| * end of the line that got cropped, then the fill-state will _not_ be |
| * adjusted. |
| * This means, the fill-state always includes the cells up to the start |
| * of the right-most character, but it might or might not cover it until |
| * its end. This should be totally fine, though. You should never access |
| * multi-cell tails directly, anyway. |
| */ |
| void term_line_set_width(term_line *line, unsigned int width) { |
| assert(line); |
| |
| if (width > line->n_cells) |
| width = line->n_cells; |
| |
| line->width = width; |
| line->fill = MIN(line->fill, width); |
| } |
| |
| /** |
| * line_insert() - Insert characters and move existing cells to the right |
| * @from: position to insert cells at |
| * @num: number of cells to insert |
| * @head_char: character that is set on the first cell |
| * @head_cwidth: character-length of @head_char |
| * @attr: attribute for all inserted cells or NULL |
| * @age: current age for all modifications |
| * |
| * The INSERT operation (or writes with INSERT_MODE) writes data at a specific |
| * position on a line and shifts the existing cells to the right. Cells that are |
| * moved beyond the right hand border are discarded. |
| * |
| * This helper contains the actual INSERT implementation which is independent of |
| * the data written. It works on cells, not on characters. The first cell is set |
| * to @head_char, all others are reset to TERM_CHAR_NULL. See each caller for a |
| * more detailed description. |
| */ |
| static inline void line_insert(term_line *line, unsigned int from, unsigned int num, term_char_t head_char, unsigned int head_cwidth, const term_attr *attr, term_age_t age) { |
| unsigned int i, rem, move; |
| |
| if (from >= line->width) |
| return; |
| if (from + num < from || from + num > line->width) |
| num = line->width - from; |
| if (!num) |
| return; |
| |
| move = line->width - from - num; |
| rem = MIN(num, move); |
| |
| if (rem > 0) { |
| /* |
| * Make room for @num cells; shift cells to the right if |
| * required. @rem is the number of remaining cells that we will |
| * knock off on the right and overwrite during the right shift. |
| * |
| * For INSERT_MODE, @num/@rem are usually 1 or 2, @move is 50% |
| * of the line on average. Therefore, the actual move is quite |
| * heavy and we can safely invalidate cells manually instead of |
| * the whole line. |
| * However, for INSERT operations, any parameters are |
| * possible. But we cannot place any assumption on its usage |
| * across applications, so we just handle it the same as |
| * INSERT_MODE and do per-cell invalidation. |
| */ |
| |
| /* destroy cells that are knocked off on the right */ |
| term_cell_destroy_n(line->cells + line->width - rem, rem); |
| |
| /* move remaining bulk of cells */ |
| memmove(line->cells + from + num, |
| line->cells + from, |
| sizeof(*line->cells) * move); |
| |
| /* invalidate cells */ |
| for (i = 0; i < move; ++i) |
| line->cells[from + num + i].age = age; |
| |
| /* initialize fresh head-cell */ |
| term_cell_init(line->cells + from, |
| head_char, |
| head_cwidth, |
| attr, |
| age); |
| |
| /* initialize fresh tail-cells */ |
| term_cell_init_n(line->cells + from + 1, |
| num - 1, |
| attr, |
| age); |
| |
| /* adjust fill-state */ |
| DISABLE_WARNING_SHADOW; |
| line->fill = MIN(line->width, |
| MAX(line->fill + num, |
| from + num)); |
| REENABLE_WARNING; |
| } else { |
| /* modify head-cell */ |
| term_cell_set(line->cells + from, |
| head_char, |
| head_cwidth, |
| attr, |
| age); |
| |
| /* reset tail-cells */ |
| term_cell_clear_n(line->cells + from + 1, |
| num - 1, |
| attr, |
| age); |
| |
| /* adjust fill-state */ |
| line->fill = line->width; |
| } |
| } |
| |
| /** |
| * term_line_write() - Write to a single, specific cell |
| * @line: line to write to |
| * @pos_x: x-position of cell in @line to write to |
| * @ch: character to write to the cell |
| * @cwidth: character width of @ch |
| * @attr: attributes to set on the cell or NULL |
| * @age: current age for all modifications |
| * @insert_mode: true if INSERT-MODE is enabled |
| * |
| * This writes to a specific cell in a line. The cell is addressed by its |
| * X-position @pos_x. If that cell does not exist, this is a no-op. |
| * |
| * @ch and @attr are set on this cell. |
| * |
| * If @insert_mode is true, this inserts the character instead of overwriting |
| * existing data (existing data is now moved to the right before writing). |
| * |
| * This function is the low-level handler of normal writes to a terminal. |
| */ |
| void term_line_write(term_line *line, unsigned int pos_x, term_char_t ch, unsigned int cwidth, const term_attr *attr, term_age_t age, bool insert_mode) { |
| unsigned int len; |
| |
| assert(line); |
| |
| if (pos_x >= line->width) |
| return; |
| |
| len = MAX(1U, cwidth); |
| if (pos_x + len < pos_x || pos_x + len > line->width) |
| len = line->width - pos_x; |
| if (!len) |
| return; |
| |
| if (insert_mode) { |
| /* Use line_insert() to insert the character-head and fill |
| * the remains with NULLs. */ |
| line_insert(line, pos_x, len, ch, cwidth, attr, age); |
| } else { |
| /* modify head-cell */ |
| term_cell_set(line->cells + pos_x, ch, cwidth, attr, age); |
| |
| /* reset tail-cells */ |
| term_cell_clear_n(line->cells + pos_x + 1, |
| len - 1, |
| attr, |
| age); |
| |
| /* adjust fill-state */ |
| DISABLE_WARNING_SHADOW; |
| line->fill = MIN(line->width, |
| MAX(line->fill, |
| pos_x + len)); |
| REENABLE_WARNING; |
| } |
| } |
| |
| /** |
| * term_line_insert() - Insert empty cells |
| * @line: line to insert empty cells into |
| * @from: x-position where to insert cells |
| * @num: number of cells to insert |
| * @attr: attributes to set on the cells or NULL |
| * @age: current age for all modifications |
| * |
| * This inserts @num empty cells at position @from in line @line. All existing |
| * cells to the right are shifted to make room for the new cells. Cells that get |
| * pushed beyond the right hand border are discarded. |
| */ |
| void term_line_insert(term_line *line, unsigned int from, unsigned int num, const term_attr *attr, term_age_t age) { |
| /* use line_insert() to insert @num empty cells */ |
| return line_insert(line, from, num, TERM_CHAR_NULL, 0, attr, age); |
| } |
| |
| /** |
| * term_line_delete() - Delete cells from line |
| * @line: line to delete cells from |
| * @from: position to delete cells at |
| * @num: number of cells to delete |
| * @attr: attributes to set on any new cells |
| * @age: current age for all modifications |
| * |
| * Delete cells from a line. All cells to the right of the deleted cells are |
| * shifted to the left to fill the empty space. New cells appearing on the right |
| * hand border are cleared and initialized with @attr. |
| */ |
| void term_line_delete(term_line *line, unsigned int from, unsigned int num, const term_attr *attr, term_age_t age) { |
| unsigned int rem, move, i; |
| |
| assert(line); |
| |
| if (from >= line->width) |
| return; |
| if (from + num < from || from + num > line->width) |
| num = line->width - from; |
| if (!num) |
| return; |
| |
| /* destroy and move as many upfront as possible */ |
| move = line->width - from - num; |
| rem = MIN(num, move); |
| if (rem > 0) { |
| /* destroy to be removed cells */ |
| term_cell_destroy_n(line->cells + from, rem); |
| |
| /* move tail upfront */ |
| memmove(line->cells + from, |
| line->cells + from + num, |
| sizeof(*line->cells) * move); |
| |
| /* invalidate copied cells */ |
| for (i = 0; i < move; ++i) |
| line->cells[from + i].age = age; |
| |
| /* initialize tail that was moved away */ |
| term_cell_init_n(line->cells + line->width - rem, |
| rem, |
| attr, |
| age); |
| |
| /* reset remaining cells in case the move was too small */ |
| if (num > move) |
| term_cell_clear_n(line->cells + from + move, |
| num - move, |
| attr, |
| age); |
| } else { |
| /* reset cells */ |
| term_cell_clear_n(line->cells + from, |
| num, |
| attr, |
| age); |
| } |
| |
| /* adjust fill-state */ |
| if (from + num < line->fill) |
| line->fill -= num; |
| else if (from < line->fill) |
| line->fill = from; |
| } |
| |
| /** |
| * term_line_append_combchar() - Append combining char to existing cell |
| * @line: line to modify |
| * @pos_x: position of cell to append combining char to |
| * @ucs4: combining character to append |
| * @age: current age for all modifications |
| * |
| * Unicode allows trailing combining characters, which belong to the |
| * char in front of them. The caller is responsible of detecting |
| * combining characters and calling term_line_append_combchar() instead of |
| * term_line_write(). This simply appends the char to the correct cell then. |
| * If the cell is not in the visible area, this call is skipped. |
| * |
| * Note that control-sequences are not 100% compatible with combining |
| * characters as they require delayed parsing. However, we must handle |
| * control-sequences immediately. Therefore, there might be trailing |
| * combining chars that should be discarded by the parser. |
| * However, to prevent programming errors, we're also being pedantic |
| * here and discard weirdly placed combining chars. This prevents |
| * situations were invalid content is parsed into the terminal and you |
| * might end up with cells containing only combining chars. |
| * |
| * Long story short: To get combining-characters working with old-fashioned |
| * terminal-emulation, we parse them exclusively for direct cell-writes. Other |
| * combining-characters are usually simply discarded and ignored. |
| */ |
| void term_line_append_combchar(term_line *line, unsigned int pos_x, uint32_t ucs4, term_age_t age) { |
| assert(line); |
| |
| if (pos_x >= line->width) |
| return; |
| |
| /* Unused cell? Skip appending any combining chars then. */ |
| if (term_char_is_null(line->cells[pos_x].ch)) |
| return; |
| |
| term_cell_append(line->cells + pos_x, ucs4, age); |
| } |
| |
| /** |
| * term_line_erase() - Erase parts of a line |
| * @line: line to modify |
| * @from: position to start the erase |
| * @num: number of cells to erase |
| * @attr: attributes to initialize erased cells with |
| * @age: current age for all modifications |
| * @keep_protected: true if protected cells should be kept |
| * |
| * This is the standard erase operation. It clears all cells in the targetted |
| * area and re-initializes them. Cells to the right are not shifted left, you |
| * must use DELETE to achieve that. Cells outside the visible area are skipped. |
| * |
| * If @keep_protected is true, protected cells will not be erased. |
| */ |
| void term_line_erase(term_line *line, unsigned int from, unsigned int num, const term_attr *attr, term_age_t age, bool keep_protected) { |
| term_cell *cell; |
| unsigned int i, last_protected; |
| |
| assert(line); |
| |
| if (from >= line->width) |
| return; |
| if (from + num < from || from + num > line->width) |
| num = line->width - from; |
| if (!num) |
| return; |
| |
| last_protected = 0; |
| for (i = 0; i < num; ++i) { |
| cell = line->cells + from + i; |
| if (keep_protected && cell->attr.protect) { |
| /* only count protected-cells inside the fill-region */ |
| if (from + i < line->fill) |
| last_protected = from + i; |
| |
| continue; |
| } |
| |
| term_cell_set(cell, TERM_CHAR_NULL, 0, attr, age); |
| } |
| |
| /* Adjust fill-state. This is a bit tricks, we can only adjust it in |
| * case the erase-region starts inside the fill-region and ends at the |
| * tail or beyond the fill-region. Otherwise, the current fill-state |
| * stays as it was. |
| * Furthermore, we must account for protected cells. The loop above |
| * ensures that protected-cells are only accounted for if they're |
| * inside the fill-region. */ |
| if (from < line->fill && from + num >= line->fill) |
| line->fill = MAX(from, last_protected); |
| } |
| |
| /** |
| * term_line_reset() - Reset a line |
| * @line: line to reset |
| * @attr: attributes to initialize all cells with |
| * @age: current age for all modifications |
| * |
| * This resets all visible cells of a line and sets their attributes and ages |
| * to @attr and @age. This is equivalent to erasing a whole line via |
| * term_line_erase(). |
| */ |
| void term_line_reset(term_line *line, const term_attr *attr, term_age_t age) { |
| assert(line); |
| |
| return term_line_erase(line, 0, line->width, attr, age, 0); |
| } |
| |
| /** |
| * term_line_link() - Link line in front of a list |
| * @line: line to link |
| * @first: member pointing to first entry |
| * @last: member pointing to last entry |
| * |
| * This links a line into a list of lines. The line is inserted at the front and |
| * must not be linked, yet. See the TERM_LINE_LINK() macro for an easier usage of |
| * this. |
| */ |
| void term_line_link(term_line *line, term_line **first, term_line **last) { |
| assert(line); |
| assert(first); |
| assert(last); |
| assert(!line->lines_prev); |
| assert(!line->lines_next); |
| |
| line->lines_prev = NULL; |
| line->lines_next = *first; |
| if (*first) |
| (*first)->lines_prev = line; |
| else |
| *last = line; |
| *first = line; |
| } |
| |
| /** |
| * term_line_link_tail() - Link line at tail of a list |
| * @line: line to link |
| * @first: member pointing to first entry |
| * @last: member pointing to last entry |
| * |
| * Same as term_line_link() but links the line at the tail. |
| */ |
| void term_line_link_tail(term_line *line, term_line **first, term_line **last) { |
| assert(line); |
| assert(first); |
| assert(last); |
| assert(!line->lines_prev); |
| assert(!line->lines_next); |
| |
| line->lines_next = NULL; |
| line->lines_prev = *last; |
| if (*last) |
| (*last)->lines_next = line; |
| else |
| *first = line; |
| *last = line; |
| } |
| |
| /** |
| * term_line_unlink() - Unlink line from a list |
| * @line: line to unlink |
| * @first: member pointing to first entry |
| * @last: member pointing to last entry |
| * |
| * This unlinks a previously linked line. See TERM_LINE_UNLINK() for an easier to |
| * use macro. |
| */ |
| void term_line_unlink(term_line *line, term_line **first, term_line **last) { |
| assert(line); |
| assert(first); |
| assert(last); |
| |
| if (line->lines_prev) |
| line->lines_prev->lines_next = line->lines_next; |
| else |
| *first = line->lines_next; |
| if (line->lines_next) |
| line->lines_next->lines_prev = line->lines_prev; |
| else |
| *last = line->lines_prev; |
| |
| line->lines_prev = NULL; |
| line->lines_next = NULL; |
| } |
| |
| /** |
| * term_page_new() - Allocate new page |
| * @out: storage for pointer to new page |
| * |
| * Allocate a new page. The initial dimensions are 0/0. |
| * |
| * Returns: 0 on success, negative error code on failure. |
| */ |
| int term_page_new(term_page **out) { |
| _term_page_free_ term_page *page = NULL; |
| |
| assert_return(out, -EINVAL); |
| |
| page = new0(term_page, 1); |
| if (!page) |
| return -ENOMEM; |
| |
| *out = page; |
| page = NULL; |
| return 0; |
| } |
| |
| /** |
| * term_page_free() - Free page |
| * @page: page to free or NULL |
| * |
| * Free a previously allocated page and all associated data. If @page is NULL, |
| * this is a no-op. |
| * |
| * Returns: NULL |
| */ |
| term_page *term_page_free(term_page *page) { |
| unsigned int i; |
| |
| if (!page) |
| return NULL; |
| |
| for (i = 0; i < page->n_lines; ++i) |
| term_line_free(page->lines[i]); |
| |
| free(page->line_cache); |
| free(page->lines); |
| free(page); |
| |
| return NULL; |
| } |
| |
| /** |
| * term_page_get_cell() - Return pointer to requested cell |
| * @page: page to operate on |
| * @x: x-position of cell |
| * @y: y-position of cell |
| * |
| * This returns a pointer to the cell at position @x/@y. You're free to modify |
| * this cell as much as you like. However, once you call any other function on |
| * the page, you must drop the pointer to the cell. |
| * |
| * Returns: Pointer to the cell or NULL if out of the visible area. |
| */ |
| term_cell *term_page_get_cell(term_page *page, unsigned int x, unsigned int y) { |
| assert_return(page, NULL); |
| |
| if (x >= page->width) |
| return NULL; |
| if (y >= page->height) |
| return NULL; |
| |
| return &page->lines[y]->cells[x]; |
| } |
| |
| /** |
| * page_scroll_up() - Scroll up |
| * @page: page to operate on |
| * @new_width: width to use for any new line moved into the visible area |
| * @num: number of lines to scroll up |
| * @attr: attributes to set on new lines |
| * @age: age to use for all modifications |
| * @history: history to use for old lines or NULL |
| * |
| * This scrolls the scroll-region by @num lines. New lines are cleared and reset |
| * with the given attributes. Old lines are moved into the history if non-NULL. |
| * If a new line is allocated, moved from the history buffer or moved from |
| * outside the visible region into the visible region, this call makes sure it |
| * has at least @width cells allocated. If a possible memory-allocation fails, |
| * the previous line is reused. This has the side effect, that it will not be |
| * linked into the history buffer. |
| * |
| * If the scroll-region is empty, this is a no-op. |
| */ |
| static void page_scroll_up(term_page *page, unsigned int new_width, unsigned int num, const term_attr *attr, term_age_t age, term_history *history) { |
| term_line *line, **cache; |
| unsigned int i; |
| int r; |
| |
| assert(page); |
| |
| if (num > page->scroll_num) |
| num = page->scroll_num; |
| if (num < 1) |
| return; |
| |
| /* Better safe than sorry: avoid under-allocating lines, even when |
| * resizing. */ |
| new_width = MAX(new_width, page->width); |
| |
| cache = page->line_cache; |
| |
| /* Try moving lines into history and allocate new lines for each moved |
| * line. In case allocation fails, or if we have no history, reuse the |
| * line. |
| * We keep the lines in the line-cache so we can safely move the |
| * remaining lines around. */ |
| for (i = 0; i < num; ++i) { |
| line = page->lines[page->scroll_idx + i]; |
| |
| r = -EAGAIN; |
| if (history) { |
| r = term_line_new(&cache[i]); |
| if (r >= 0) { |
| r = term_line_reserve(cache[i], |
| new_width, |
| attr, |
| age, |
| 0); |
| if (r < 0) |
| term_line_free(cache[i]); |
| else |
| term_line_set_width(cache[i], page->width); |
| } |
| } |
| |
| if (r >= 0) { |
| term_history_push(history, line); |
| } else { |
| cache[i] = line; |
| term_line_reset(line, attr, age); |
| } |
| } |
| |
| if (num < page->scroll_num) { |
| memmove(page->lines + page->scroll_idx, |
| page->lines + page->scroll_idx + num, |
| sizeof(*page->lines) * (page->scroll_num - num)); |
| |
| /* update age of moved lines */ |
| for (i = 0; i < page->scroll_num - num; ++i) |
| page->lines[page->scroll_idx + i]->age = age; |
| } |
| |
| /* copy remaining lines from cache; age is already updated */ |
| memcpy(page->lines + page->scroll_idx + page->scroll_num - num, |
| cache, |
| sizeof(*cache) * num); |
| |
| /* update fill */ |
| page->scroll_fill -= MIN(page->scroll_fill, num); |
| } |
| |
| /** |
| * page_scroll_down() - Scroll down |
| * @page: page to operate on |
| * @new_width: width to use for any new line moved into the visible area |
| * @num: number of lines to scroll down |
| * @attr: attributes to set on new lines |
| * @age: age to use for all modifications |
| * @history: history to use for new lines or NULL |
| * |
| * This scrolls the scroll-region by @num lines. New lines are retrieved from |
| * the history or cleared if the history is empty or NULL. |
| * |
| * Usually, scroll-down implies that new lines are cleared. Therefore, you're |
| * highly encouraged to set @history to NULL. However, if you resize a terminal, |
| * you might want to include history-lines in the new area. In that case, you |
| * should set @history to non-NULL. |
| * |
| * If a new line is allocated, moved from the history buffer or moved from |
| * outside the visible region into the visible region, this call makes sure it |
| * has at least @width cells allocated. If a possible memory-allocation fails, |
| * the previous line is reused. This will have the side-effect that lines from |
| * the history will not get visible on-screen but kept in history. |
| * |
| * If the scroll-region is empty, this is a no-op. |
| */ |
| static void page_scroll_down(term_page *page, unsigned int new_width, unsigned int num, const term_attr *attr, term_age_t age, term_history *history) { |
| term_line *line, **cache, *t; |
| unsigned int i, last_idx; |
| |
| assert(page); |
| |
| if (num > page->scroll_num) |
| num = page->scroll_num; |
| if (num < 1) |
| return; |
| |
| /* Better safe than sorry: avoid under-allocating lines, even when |
| * resizing. */ |
| new_width = MAX(new_width, page->width); |
| |
| cache = page->line_cache; |
| last_idx = page->scroll_idx + page->scroll_num - 1; |
| |
| /* Try pulling out lines from history; if history is empty or if no |
| * history is given, we reuse the to-be-removed lines. Otherwise, those |
| * lines are released. */ |
| for (i = 0; i < num; ++i) { |
| line = page->lines[last_idx - i]; |
| |
| t = NULL; |
| if (history) |
| t = term_history_pop(history, new_width, attr, age); |
| |
| if (t) { |
| cache[num - 1 - i] = t; |
| term_line_free(line); |
| } else { |
| cache[num - 1 - i] = line; |
| term_line_reset(line, attr, age); |
| } |
| } |
| |
| if (num < page->scroll_num) { |
| memmove(page->lines + page->scroll_idx + num, |
| page->lines + page->scroll_idx, |
| sizeof(*page->lines) * (page->scroll_num - num)); |
| |
| /* update age of moved lines */ |
| for (i = 0; i < page->scroll_num - num; ++i) |
| page->lines[page->scroll_idx + num + i]->age = age; |
| } |
| |
| /* copy remaining lines from cache; age is already updated */ |
| memcpy(page->lines + page->scroll_idx, |
| cache, |
| sizeof(*cache) * num); |
| |
| /* update fill; but only if there's already content in it */ |
| if (page->scroll_fill > 0) |
| page->scroll_fill = MIN(page->scroll_num, |
| page->scroll_fill + num); |
| } |
| |
| /** |
| * page_reserve() - Reserve page area |
| * @page: page to modify |
| * @cols: required columns (width) |
| * @rows: required rows (height) |
| * @attr: attributes for newly allocated cells |
| * @age: age to set on any modified cells |
| * |
| * This allocates the required amount of lines and cells to guarantee that the |
| * page has at least the demanded dimensions of @cols x @rows. Note that this |
| * never shrinks the page-memory. We keep cells allocated for performance |
| * reasons. |
| * |
| * Additionally to allocating lines, this also clears any newly added cells so |
| * you can safely change the size afterwards without clearing new cells. |
| * |
| * Note that you must be careful what operations you call on the page between |
| * page_reserve() and updating page->width/height. Any newly allocated line (or |
| * shifted line) might not meet your new width/height expectations. |
| * |
| * Returns: 0 on success, negative error code on failure. |
| */ |
| int term_page_reserve(term_page *page, unsigned int cols, unsigned int rows, const term_attr *attr, term_age_t age) { |
| _term_line_free_ term_line *line = NULL; |
| unsigned int i, min_lines; |
| term_line **t; |
| int r; |
| |
| assert_return(page, -EINVAL); |
| |
| /* |
| * First make sure the first MIN(page->n_lines, rows) lines have at |
| * least the required width of @cols. This does not modify any visible |
| * cells in the existing @page->width x @page->height area, therefore, |
| * we can safely bail out afterwards in case anything else fails. |
| * Note that lines in between page->height and page->n_lines might be |
| * shorter than page->width. Hence, we need to resize them all, but we |
| * can skip some of them for better performance. |
| */ |
| min_lines = MIN(page->n_lines, rows); |
| for (i = 0; i < min_lines; ++i) { |
| /* lines below page->height have at least page->width cells */ |
| if (cols < page->width && i < page->height) |
| continue; |
| |
| r = term_line_reserve(page->lines[i], |
| cols, |
| attr, |
| age, |
| (i < page->height) ? page->width : 0); |
| if (r < 0) |
| return r; |
| } |
| |
| /* |
| * We now know the first @min_lines lines have at least width @cols and |
| * are prepared for resizing. We now only have to allocate any |
| * additional lines below @min_lines in case @rows is greater than |
| * page->n_lines. |
| */ |
| if (rows > page->n_lines) { |
| t = realloc_multiply(page->lines, sizeof(*t), rows); |
| if (!t) |
| return -ENOMEM; |
| page->lines = t; |
| |
| t = realloc_multiply(page->line_cache, sizeof(*t), rows); |
| if (!t) |
| return -ENOMEM; |
| page->line_cache = t; |
| |
| while (page->n_lines < rows) { |
| r = term_line_new(&line); |
| if (r < 0) |
| return r; |
| |
| r = term_line_reserve(line, cols, attr, age, 0); |
| if (r < 0) |
| return r; |
| |
| page->lines[page->n_lines++] = line; |
| line = NULL; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * term_page_resize() - Resize page |
| * @page: page to modify |
| * @cols: number of columns (width) |
| * @rows: number of rows (height) |
| * @attr: attributes for newly allocated cells |
| * @age: age to set on any modified cells |
| * @history: history buffer to use for new/old lines or NULL |
| * |
| * This changes the visible dimensions of a page. You must have called |
| * term_page_reserve() beforehand, otherwise, this will fail. |
| * |
| * Returns: 0 on success, negative error code on failure. |
| */ |
| void term_page_resize(term_page *page, unsigned int cols, unsigned int rows, const term_attr *attr, term_age_t age, term_history *history) { |
| unsigned int i, num, empty, max, old_height; |
| term_line *line; |
| |
| assert(page); |
| assert(page->n_lines >= rows); |
| |
| old_height = page->height; |
| |
| if (rows < old_height) { |
| /* |
| * If we decrease the terminal-height, we emulate a scroll-up. |
| * This way, existing data from the scroll-area is moved into |
| * the history, making space at the bottom to reduce the screen |
| * height. In case the scroll-fill indicates empty lines, we |
| * reduce the amount of scrolled lines. |
| * Once scrolled, we have to move the lower margin from below |
| * the scroll area up so it is preserved. |
| */ |
| |
| /* move lines to history if scroll region is filled */ |
| num = old_height - rows; |
| empty = page->scroll_num - page->scroll_fill; |
| if (num > empty) |
| page_scroll_up(page, |
| cols, |
| num - empty, |
| attr, |
| age, |
| history); |
| |
| /* move lower margin up; drop its lines if not enough space */ |
| num = LESS_BY(old_height, page->scroll_idx + page->scroll_num); |
| max = LESS_BY(rows, page->scroll_idx); |
| num = MIN(num, max); |
| if (num > 0) { |
| unsigned int top, bottom; |
| |
| top = rows - num; |
| bottom = page->scroll_idx + page->scroll_num; |
| |
| /* might overlap; must run topdown, not bottomup */ |
| for (i = 0; i < num; ++i) { |
| line = page->lines[top + i]; |
| page->lines[top + i] = page->lines[bottom + i]; |
| page->lines[bottom + i] = line; |
| } |
| } |
| |
| /* update vertical extents */ |
| page->height = rows; |
| page->scroll_idx = MIN(page->scroll_idx, rows); |
| page->scroll_num -= MIN(page->scroll_num, old_height - rows); |
| /* fill is already up-to-date or 0 due to scroll-up */ |
| } else if (rows > old_height) { |
| /* |
| * If we increase the terminal-height, we emulate a scroll-down |
| * and fetch new lines from the history. |
| * New lines are always accounted to the scroll-region. Thus we |
| * have to preserve the lower margin first, by moving it down. |
| */ |
| |
| /* move lower margin down */ |
| num = LESS_BY(old_height, page->scroll_idx + page->scroll_num); |
| if (num > 0) { |
| unsigned int top, bottom; |
| |
| top = page->scroll_idx + page->scroll_num; |
| bottom = top + (rows - old_height); |
| |
| /* might overlap; must run bottomup, not topdown */ |
| for (i = num; i-- > 0; ) { |
| line = page->lines[top + i]; |
| page->lines[top + i] = page->lines[bottom + i]; |
| page->lines[bottom + i] = line; |
| } |
| } |
| |
| /* update vertical extents */ |
| page->height = rows; |
| page->scroll_num = MIN(LESS_BY(rows, page->scroll_idx), |
| page->scroll_num + (rows - old_height)); |
| |
| /* check how many lines can be received from history */ |
| if (history) |
| num = term_history_peek(history, |
| rows - old_height, |
| cols, |
| attr, |
| age); |
| else |
| num = 0; |
| |
| /* retrieve new lines from history if available */ |
| if (num > 0) |
| page_scroll_down(page, |
| cols, |
| num, |
| attr, |
| age, |
| history); |
| } |
| |
| /* set horizontal extents */ |
| page->width = cols; |
| for (i = 0; i < page->height; ++i) |
| term_line_set_width(page->lines[i], cols); |
| } |
| |
| /** |
| * term_page_write() - Write to a single cell |
| * @page: page to operate on |
| * @pos_x: x-position of cell to write to |
| * @pos_y: y-position of cell to write to |
| * @ch: character to write |
| * @cwidth: character-width of @ch |
| * @attr: attributes to set on the cell or NULL |
| * @age: age to use for all modifications |
| * @insert_mode: true if INSERT-MODE is enabled |
| * |
| * This writes a character to a specific cell. If the cell is beyond bounds, |
| * this is a no-op. @attr and @age are used to update the cell. @flags can be |
| * used to alter the behavior of this function. |
| * |
| * This is a wrapper around term_line_write(). |
| * |
| * This call does not wrap around lines. That is, this only operates on a single |
| * line. |
| */ |
| void term_page_write(term_page *page, unsigned int pos_x, unsigned int pos_y, term_char_t ch, unsigned int cwidth, const term_attr *attr, term_age_t age, bool insert_mode) { |
| assert(page); |
| |
| if (pos_y >= page->height) |
| return; |
| |
| term_line_write(page->lines[pos_y], pos_x, ch, cwidth, attr, age, insert_mode); |
| } |
| |
| /** |
| * term_page_insert_cells() - Insert cells into a line |
| * @page: page to operate on |
| * @from_x: x-position where to insert new cells |
| * @from_y: y-position where to insert new cells |
| * @num: number of cells to insert |
| * @attr: attributes to set on new cells or NULL |
| * @age: age to use for all modifications |
| * |
| * This inserts new cells into a given line. This is a wrapper around |
| * term_line_insert(). |
| * |
| * This call does not wrap around lines. That is, this only operates on a single |
| * line. |
| */ |
| void term_page_insert_cells(term_page *page, unsigned int from_x, unsigned int from_y, unsigned int num, const term_attr *attr, term_age_t age) { |
| assert(page); |
| |
| if (from_y >= page->height) |
| return; |
| |
| term_line_insert(page->lines[from_y], from_x, num, attr, age); |
| } |
| |
| /** |
| * term_page_delete_cells() - Delete cells from a line |
| * @page: page to operate on |
| * @from_x: x-position where to delete cells |
| * @from_y: y-position where to delete cells |
| * @num: number of cells to delete |
| * @attr: attributes to set on new cells or NULL |
| * @age: age to use for all modifications |
| * |
| * This deletes cells from a given line. This is a wrapper around |
| * term_line_delete(). |
| * |
| * This call does not wrap around lines. That is, this only operates on a single |
| * line. |
| */ |
| void term_page_delete_cells(term_page *page, unsigned int from_x, unsigned int from_y, unsigned int num, const term_attr *attr, term_age_t age) { |
| assert(page); |
| |
| if (from_y >= page->height) |
| return; |
| |
| term_line_delete(page->lines[from_y], from_x, num, attr, age); |
| } |
| |
| /** |
| * term_page_append_combchar() - Append combining-character to a cell |
| * @page: page to operate on |
| * @pos_x: x-position of target cell |
| * @pos_y: y-position of target cell |
| * @ucs4: combining character to append |
| * @age: age to use for all modifications |
| * |
| * This appends a combining-character to a specific cell. This is a wrapper |
| * around term_line_append_combchar(). |
| */ |
| void term_page_append_combchar(term_page *page, unsigned int pos_x, unsigned int pos_y, uint32_t ucs4, term_age_t age) { |
| assert(page); |
| |
| if (pos_y >= page->height) |
| return; |
| |
| term_line_append_combchar(page->lines[pos_y], pos_x, ucs4, age); |
| } |
| |
| /** |
| * term_page_erase() - Erase parts of a page |
| * @page: page to operate on |
| * @from_x: x-position where to start erasure (inclusive) |
| * @from_y: y-position where to start erasure (inclusive) |
| * @to_x: x-position where to stop erasure (inclusive) |
| * @to_y: y-position where to stop erasure (inclusive) |
| * @attr: attributes to set on cells |
| * @age: age to use for all modifications |
| * @keep_protected: true if protected cells should be kept |
| * |
| * This erases all cells starting at @from_x/@from_y up to @to_x/@to_y. Note |
| * that this wraps around line-boundaries so lines between @from_y and @to_y |
| * are cleared entirely. |
| * |
| * Lines outside the visible area are left untouched. |
| */ |
| void term_page_erase(term_page *page, unsigned int from_x, unsigned int from_y, unsigned int to_x, unsigned int to_y, const term_attr *attr, term_age_t age, bool keep_protected) { |
| unsigned int i, from, to; |
| |
| assert(page); |
| |
| for (i = from_y; i <= to_y && i < page->height; ++i) { |
| from = 0; |
| to = page->width; |
| |
| if (i == from_y) |
| from = from_x; |
| if (i == to_y) |
| to = to_x; |
| |
| term_line_erase(page->lines[i], |
| from, |
| LESS_BY(to, from), |
| attr, |
| age, |
| keep_protected); |
| } |
| } |
| |
| /** |
| * term_page_reset() - Reset page |
| * @page: page to modify |
| * @attr: attributes to set on cells |
| * @age: age to use for all modifications |
| * |
| * This erases the whole visible page. See term_page_erase(). |
| */ |
| void term_page_reset(term_page *page, const term_attr *attr, term_age_t age) { |
| assert(page); |
| |
| return term_page_erase(page, |
| 0, 0, |
| page->width - 1, page->height - 1, |
| attr, |
| age, |
| 0); |
| } |
| |
| /** |
| * term_page_set_scroll_region() - Set scroll region |
| * @page: page to operate on |
| * @idx: start-index of scroll region |
| * @num: number of lines in scroll region |
| * |
| * This sets the scroll region of a page. Whenever an operation needs to scroll |
| * lines, it scrolls them inside of that region. Lines outside the region are |
| * left untouched. In case a scroll-operation is targeted outside of this |
| * region, it will implicitly get a scroll-region of only one line (i.e., no |
| * scroll region at all). |
| * |
| * Note that the scroll-region is clipped to the current page-extents. Growing |
| * or shrinking the page always accounts new/old lines to the scroll region and |
| * moves top/bottom margins accordingly so they're preserved. |
| */ |
| void term_page_set_scroll_region(term_page *page, unsigned int idx, unsigned int num) { |
| assert(page); |
| |
| if (page->height < 1) { |
| page->scroll_idx = 0; |
| page->scroll_num = 0; |
| } else { |
| page->scroll_idx = MIN(idx, page->height - 1); |
| page->scroll_num = MIN(num, page->height - page->scroll_idx); |
| } |
| } |
| |
| /** |
| * term_page_scroll_up() - Scroll up |
| * @page: page to operate on |
| * @num: number of lines to scroll up |
| * @attr: attributes to set on new lines |
| * @age: age to use for all modifications |
| * @history: history to use for old lines or NULL |
| * |
| * This scrolls the scroll-region by @num lines. New lines are cleared and reset |
| * with the given attributes. Old lines are moved into the history if non-NULL. |
| * |
| * If the scroll-region is empty, this is a no-op. |
| */ |
| void term_page_scroll_up(term_page *page, unsigned int num, const term_attr *attr, term_age_t age, term_history *history) { |
| page_scroll_up(page, page->width, num, attr, age, history); |
| } |
| |
| /** |
| * term_page_scroll_down() - Scroll down |
| * @page: page to operate on |
| * @num: number of lines to scroll down |
| * @attr: attributes to set on new lines |
| * @age: age to use for all modifications |
| * @history: history to use for new lines or NULL |
| * |
| * This scrolls the scroll-region by @num lines. New lines are retrieved from |
| * the history or cleared if the history is empty or NULL. |
| * |
| * Usually, scroll-down implies that new lines are cleared. Therefore, you're |
| * highly encouraged to set @history to NULL. However, if you resize a terminal, |
| * you might want to include history-lines in the new area. In that case, you |
| * should set @history to non-NULL. |
| * |
| * If the scroll-region is empty, this is a no-op. |
| */ |
| void term_page_scroll_down(term_page *page, unsigned int num, const term_attr *attr, term_age_t age, term_history *history) { |
| page_scroll_down(page, page->width, num, attr, age, history); |
| } |
| |
| /** |
| * term_page_insert_lines() - Insert new lines |
| * @page: page to operate on |
| * @pos_y: y-position where to insert new lines |
| * @num: number of lines to insert |
| * @attr: attributes to set on new lines |
| * @age: age to use for all modifications |
| * |
| * This inserts @num new lines at position @pos_y. If @pos_y is beyond |
| * boundaries or @num is 0, this is a no-op. |
| * All lines below @pos_y are moved down to make space for the new lines. Lines |
| * on the bottom are dropped. Note that this only moves lines above or inside |
| * the scroll-region. If @pos_y is below the scroll-region, a scroll-region of |
| * one line is implied (which means the line is simply cleared). |
| */ |
| void term_page_insert_lines(term_page *page, unsigned int pos_y, unsigned int num, const term_attr *attr, term_age_t age) { |
| unsigned int scroll_idx, scroll_num; |
| |
| assert(page); |
| |
| if (pos_y >= page->height) |
| return; |
| if (num >= page->height) |
| num = page->height; |
| |
| /* remember scroll-region */ |
| scroll_idx = page->scroll_idx; |
| scroll_num = page->scroll_num; |
| |
| /* set scroll-region temporarily so we can reuse scroll_down() */ |
| { |
| page->scroll_idx = pos_y; |
| if (pos_y >= scroll_idx + scroll_num) |
| page->scroll_num = 1; |
| else if (pos_y >= scroll_idx) |
| page->scroll_num -= pos_y - scroll_idx; |
| else |
| page->scroll_num += scroll_idx - pos_y; |
| |
| term_page_scroll_down(page, num, attr, age, NULL); |
| } |
| |
| /* reset scroll-region */ |
| page->scroll_idx = scroll_idx; |
| page->scroll_num = scroll_num; |
| } |
| |
| /** |
| * term_page_delete_lines() - Delete lines |
| * @page: page to operate on |
| * @pos_y: y-position where to delete lines |
| * @num: number of lines to delete |
| * @attr: attributes to set on new lines |
| * @age: age to use for all modifications |
| * |
| * This deletes @num lines at position @pos_y. If @pos_y is beyond boundaries or |
| * @num is 0, this is a no-op. |
| * All lines below @pos_y are moved up into the newly made space. New lines |
| * on the bottom are clear. Note that this only moves lines above or inside |
| * the scroll-region. If @pos_y is below the scroll-region, a scroll-region of |
| * one line is implied (which means the line is simply cleared). |
| */ |
| void term_page_delete_lines(term_page *page, unsigned int pos_y, unsigned int num, const term_attr *attr, term_age_t age) { |
| unsigned int scroll_idx, scroll_num; |
| |
| assert(page); |
| |
| if (pos_y >= page->height) |
| return; |
| if (num >= page->height) |
| num = page->height; |
| |
| /* remember scroll-region */ |
| scroll_idx = page->scroll_idx; |
| scroll_num = page->scroll_num; |
| |
| /* set scroll-region temporarily so we can reuse scroll_up() */ |
| { |
| page->scroll_idx = pos_y; |
| if (pos_y >= scroll_idx + scroll_num) |
| page->scroll_num = 1; |
| else if (pos_y > scroll_idx) |
| page->scroll_num -= pos_y - scroll_idx; |
| else |
| page->scroll_num += scroll_idx - pos_y; |
| |
| term_page_scroll_up(page, num, attr, age, NULL); |
| } |
| |
| /* reset scroll-region */ |
| page->scroll_idx = scroll_idx; |
| page->scroll_num = scroll_num; |
| } |
| |
| /** |
| * term_history_new() - Create new history object |
| * @out: storage for pointer to new history |
| * |
| * Create a new history object. Histories are used to store scrollback-lines |
| * from VTE pages. You're highly recommended to set a history-limit on |
| * history->max_lines and trim it via term_history_trim(), otherwise history |
| * allocations are unlimited. |
| * |
| * Returns: 0 on success, negative error code on failure. |
| */ |
| int term_history_new(term_history **out) { |
| _term_history_free_ term_history *history = NULL; |
| |
| assert_return(out, -EINVAL); |
| |
| history = new0(term_history, 1); |
| if (!history) |
| return -ENOMEM; |
| |
| history->max_lines = 4096; |
| |
| *out = history; |
| history = NULL; |
| return 0; |
| } |
| |
| /** |
| * term_history_free() - Free history |
| * @history: history to free |
| * |
| * Clear and free history. You must not access the object afterwards. |
| * |
| * Returns: NULL |
| */ |
| term_history *term_history_free(term_history *history) { |
| if (!history) |
| return NULL; |
| |
| term_history_clear(history); |
| free(history); |
| return NULL; |
| } |
| |
| /** |
| * term_history_clear() - Clear history |
| * @history: history to clear |
| * |
| * Remove all linked lines from a history and reset it to its initial state. |
| */ |
| void term_history_clear(term_history *history) { |
| return term_history_trim(history, 0); |
| } |
| |
| /** |
| * term_history_trim() - Trim history |
| * @history: history to trim |
| * @max: maximum number of lines to be left in history |
| * |
| * This removes lines from the history until it is smaller than @max. Lines are |
| * removed from the top. |
| */ |
| void term_history_trim(term_history *history, unsigned int max) { |
| term_line *line; |
| |
| if (!history) |
| return; |
| |
| while (history->n_lines > max && (line = history->lines_first)) { |
| TERM_LINE_UNLINK(line, history); |
| term_line_free(line); |
| --history->n_lines; |
| } |
| } |
| |
| /** |
| * term_history_push() - Push line into history |
| * @history: history to work on |
| * @line: line to push into history |
| * |
| * This pushes a line into the given history. It is linked at the tail. In case |
| * the history is limited, the top-most line might be freed. |
| */ |
| void term_history_push(term_history *history, term_line *line) { |
| assert(history); |
| assert(line); |
| |
| TERM_LINE_LINK_TAIL(line, history); |
| if (history->max_lines > 0 && history->n_lines >= history->max_lines) { |
| line = history->lines_first; |
| TERM_LINE_UNLINK(line, history); |
| term_line_free(line); |
| } else { |
| ++history->n_lines; |
| } |
| } |
| |
| /** |
| * term_history_pop() - Retrieve last line from history |
| * @history: history to work on |
| * @new_width: width to reserve and set on the line |
| * @attr: attributes to use for cell reservation |
| * @age: age to use for cell reservation |
| * |
| * This unlinks the last linked line of the history and returns it. This also |
| * makes sure the line has the given width pre-allocated (see |
| * term_line_reserve()). If the pre-allocation fails, this returns NULL, so it |
| * is treated like there's no line in history left. This simplifies |
| * history-handling on the caller's side in case of allocation errors. No need |
| * to throw lines away just because the reservation failed. We can keep them in |
| * history safely, and make them available as scrollback. |
| * |
| * Returns: Line from history or NULL |
| */ |
| term_line *term_history_pop(term_history *history, unsigned int new_width, const term_attr *attr, term_age_t age) { |
| term_line *line; |
| int r; |
| |
| assert_return(history, NULL); |
| |
| line = history->lines_last; |
| if (!line) |
| return NULL; |
| |
| r = term_line_reserve(line, new_width, attr, age, line->width); |
| if (r < 0) |
| return NULL; |
| |
| term_line_set_width(line, new_width); |
| TERM_LINE_UNLINK(line, history); |
| --history->n_lines; |
| |
| return line; |
| } |
| |
| /** |
| * term_history_peek() - Return number of available history-lines |
| * @history: history to work on |
| * @max: maximum number of lines to look at |
| * @reserve_width: width to reserve on the line |
| * @attr: attributes to use for cell reservation |
| * @age: age to use for cell reservation |
| * |
| * This returns the number of available lines in the history given as @history. |
| * It returns at most @max. For each line that is looked at, the line is |
| * verified to have at least @reserve_width cells. Valid cells are preserved, |
| * new cells are initialized with @attr and @age. In case an allocation fails, |
| * we bail out and return the number of lines that are valid so far. |
| * |
| * Usually, this function should be used before running a loop on |
| * term_history_pop(). This function guarantees that term_history_pop() (with |
| * the same arguments) will succeed at least the returned number of times. |
| * |
| * Returns: Number of valid lines that can be received via term_history_pop(). |
| */ |
| unsigned int term_history_peek(term_history *history, unsigned int max, unsigned int reserve_width, const term_attr *attr, term_age_t age) { |
| unsigned int num; |
| term_line *line; |
| int r; |
| |
| assert(history); |
| |
| num = 0; |
| line = history->lines_last; |
| |
| while (num < max && line) { |
| r = term_line_reserve(line, reserve_width, attr, age, line->width); |
| if (r < 0) |
| break; |
| |
| ++num; |
| line = line->lines_prev; |
| } |
| |
| return num; |
| } |