#include "termpaint.h"
#include "termpaintx.h"
void event_callback(void *userdata, termpaint_event *event) {
bool *quit = userdata;
if (event->type == TERMPAINT_EV_CHAR) {
*quit = true;
}
if (event->type == TERMPAINT_EV_KEY) {
*quit = true;
}
}
int main(int argc, char **argv) {
if (argc != 2) {
printf("Usage: %s filename\n", argv[0]);
return 1;
}
FILE *fp = fopen(argv[1], "r");
if (!fp) {
perror("Error opening file");
return 1;
}
char *buffer = calloc(40000, 1);
if (!buffer) {
puts("Out of memory\n");
fclose(fp);
return 1;
}
(void)!fread(buffer, 1, 39999, fp); // already nul filled, error checking on next line
if (ferror(fp)) {
perror("Error reading file");
fclose(fp);
free(buffer);
return 1;
}
fclose(fp);
termpaint_integration *integration;
termpaint_terminal *terminal;
termpaint_surface *surface;
bool quit = false;
integration = termpaintx_full_integration_setup_terminal_fullscreen(
"+kbdsig +kbdsigint",
event_callback, &quit,
&terminal);
surface = termpaint_terminal_get_surface(terminal);
termpaint_surface_clear(surface,
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
const int width = termpaint_surface_width(surface);
const int height = termpaint_surface_height(surface);
termpaint_text_measurement *m = termpaint_text_measurement_new(surface);
termpaint_attr *attr = termpaint_attr_new(TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
int y = 0;
const char* cur = buffer;
do {
const char* linebreak = strchr(cur, '\n');
int count;
if (!linebreak) {
count = strlen(cur);
} else {
count = linebreak - cur;
}
termpaint_text_measurement_reset(m);
termpaint_text_measurement_set_limit_width(m, width);
termpaint_text_measurement_feed_utf8(m, cur, count, true);
const int bytes = termpaint_text_measurement_last_ref(m);
if (bytes != count) {
// needs break
// try to find a word break
int print_bytes = bytes;
int skip_bytes = bytes;
for (const char *p = cur + bytes; p > cur; p--) {
if (*p == ' ') {
skip_bytes = print_bytes = p - cur;
// the space is always a start of a cluster.
// when skipping the space itself after the wrap
// care needs to be taken to only skip the space if it is the
// sole character of its cluster
termpaint_text_measurement_reset(m);
termpaint_text_measurement_set_limit_clusters(m, 1);
termpaint_text_measurement_feed_utf8(m, cur + skip_bytes, count - skip_bytes, true);
if (termpaint_text_measurement_last_ref(m) == 1) {
skip_bytes += 1;
}
break;
}
}
termpaint_surface_write_with_len_attr_clipped(surface,
0, y, cur, print_bytes,
attr,
0, width);
cur += skip_bytes;
} else {
// fits completely
termpaint_surface_write_with_len_attr_clipped(surface,
0, y, cur, count,
attr,
0, width);
cur += count + 1;
}
y += 1;
if (!linebreak) break;
} while (y < height);
termpaint_text_measurement_free(m);
termpaint_attr_free(attr);
termpaint_terminal_flush(terminal, false);
while (!quit) {
if (!termpaintx_full_integration_do_iteration(integration)) {
// some kind of error
break;
}
}
termpaint_terminal_free_with_restore(terminal);
return 0;
}
termpaint-0.3.1/doc/ 0000775 0000000 0000000 00000000000 14773035472 0014277 5 ustar 00root root 0000000 0000000 termpaint-0.3.1/doc/_static/ 0000775 0000000 0000000 00000000000 14773035472 0015725 5 ustar 00root root 0000000 0000000 termpaint-0.3.1/doc/_static/custom.css 0000664 0000000 0000000 00000000442 14773035472 0017751 0 ustar 00root root 0000000 0000000 dl.macro dt { text-indent: -120px; margin-left: 120px; }
dl.function dt { text-indent: -120px; margin-left: 120px; }
dl.type dt { text-indent: -120px; margin-left: 120px; }
.hidden-references {
visibility:hidden;
height: 0px;
}
div .hidden-references + p {
margin-top: 0px;
}
termpaint-0.3.1/doc/_templates/ 0000775 0000000 0000000 00000000000 14773035472 0016434 5 ustar 00root root 0000000 0000000 termpaint-0.3.1/doc/_templates/genindex.html 0000664 0000000 0000000 00000003251 14773035472 0021124 0 ustar 00root root 0000000 0000000 {#
basic/genindex.html
~~~~~~~~~~~~~~~~~~~
Template for an "all-in-one" index.
:copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
#}
{%- extends "layout.html" %}
{% set title = _('Index') %}
{% macro indexentries(firstname, links) %}
{%- if links -%}
{%- if links[0][0] %}{% endif -%}
{{ firstname|e }}
{%- if links[0][0] %}{% endif -%}
{%- for ismain, link in links[1:] -%}
, {% if ismain %}{% endif -%}
[{{ loop.index }}]
{%- if ismain %}{% endif -%}
{%- endfor %}
{%- else %}
{{ firstname|e }}
{%- endif %}
{% endmacro %}
{% block body %}
{{ _('Index') }}
{%- for key, entries in genindexentries %}
{%- for column in entries|slice_index(2) if column %}
{%- for entryname, (links, subitems, _) in column %}
{{ indexentries(entryname, links) }}
{%- if subitems %}
{%- for subentryname, subentrylinks in subitems %}
- {{ indexentries(subentryname, subentrylinks) }}
{%- endfor %}
{%- endif -%}
{%- endfor %}
{%- endfor %}
{% endfor %}
{% endblock %}
{% block sidebarrel %}
{% if split_index %}
{{ _('Index') }}
{% for key, dummy in genindexentries -%}
{{ key }}
{% if not loop.last %}| {% endif %}
{%- endfor %}
{{ _('Full index on one page') }}
{% endif %}
{{ super() }}
{% endblock %}
termpaint-0.3.1/doc/_templates/genindex.html.license 0000664 0000000 0000000 00000002330 14773035472 0022542 0 ustar 00root root 0000000 0000000 Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
termpaint-0.3.1/doc/_templates/navigation.html 0000664 0000000 0000000 00000000671 14773035472 0021465 0 ustar 00root root 0000000 0000000 {{ _('Navigation') }}
{{ toctree(includehidden=theme_sidebar_includehidden, collapse=theme_sidebar_collapse) }}
{% if theme_extra_nav_links %}
{% for text, uri in theme_extra_nav_links.items() %}
- {{ text }}
{% endfor %}
{% endif %}
termpaint-0.3.1/doc/attributes.rst 0000664 0000000 0000000 00000027132 14773035472 0017224 0 ustar 00root root 0000000 0000000 .. _sec_attributes:
Attributes
==========
.. c:type:: termpaint_attr
The attributes object contains paint settings used when painting on a :doc:`surface`. It consists of the
foreground color, the background color and the decoration color. In addition it has a set of enabled styles.
.. _colors:
Colors
------
Terminal colors are a bit complicated for historical reasons. Even if colors seem the same they are all distinct and
terminals can (and do) act differently depending on how the color was exactly selected.
.. _default-colors:
Default colors
..............
The most basic color is :c:macro:`TERMPAINT_DEFAULT_COLOR`. It's the terminals default color. This color acts differently
when used as foreground, background or decoration color. For foreground and background it's the respective default color.
For decoration color the default color means that the terminal will use the foreground color of that particular cell.
.. _named-colors:
Named colors
............
Next there is the set of named colors. The first 8 named colors are also often called ANSI colors. These colors are
have constants like ``TERMPAINT_COLOR_RED`` and can also be referred to as :c:macro:`TERMPAINT_NAMED_COLOR` + color
number. The first 8 colors are supported by almost all color
terminals. The following 8 colors are still very widely supported. The named colors have names like "red", but terminal
implementations often allow reconfiguring these colors from easy accessible settings dialogs. Expect named colors to
have different concrete color values for many users.
.. container:: hidden-references
.. c:macro:: TERMPAINT_COLOR_BLACK
.. c:macro:: TERMPAINT_COLOR_RED
.. c:macro:: TERMPAINT_COLOR_GREEN
.. c:macro:: TERMPAINT_COLOR_YELLOW
.. c:macro:: TERMPAINT_COLOR_BLUE
.. c:macro:: TERMPAINT_COLOR_MAGENTA
.. c:macro:: TERMPAINT_COLOR_CYAN
.. c:macro:: TERMPAINT_COLOR_LIGHT_GREY
.. c:macro:: TERMPAINT_COLOR_DARK_GREY
.. c:macro:: TERMPAINT_COLOR_BRIGHT_RED
.. c:macro:: TERMPAINT_COLOR_BRIGHT_GREEN
.. c:macro:: TERMPAINT_COLOR_BRIGHT_YELLOW
.. c:macro:: TERMPAINT_COLOR_BRIGHT_BLUE
.. c:macro:: TERMPAINT_COLOR_BRIGHT_MAGENTA
.. c:macro:: TERMPAINT_COLOR_BRIGHT_CYAN
.. c:macro:: TERMPAINT_COLOR_WHITE
.. table:: Named Colors
:align: left
====== ============================== ====
Number Constant Name
====== ============================== ====
0 TERMPAINT_COLOR_BLACK black
1 TERMPAINT_COLOR_RED red
2 TERMPAINT_COLOR_GREEN green
3 TERMPAINT_COLOR_YELLOW yellow
4 TERMPAINT_COLOR_BLUE blue
5 TERMPAINT_COLOR_MAGENTA magenta
6 TERMPAINT_COLOR_CYAN cyan
7 TERMPAINT_COLOR_LIGHT_GREY "white" (on terminals supporting 16 colors this is light gray)
8 TERMPAINT_COLOR_DARK_GREY dark gray
9 TERMPAINT_COLOR_BRIGHT_RED bright red
10 TERMPAINT_COLOR_BRIGHT_GREEN bright green
11 TERMPAINT_COLOR_BRIGHT_YELLOW bright yellow
12 TERMPAINT_COLOR_BRIGHT_BLUE bright blue
13 TERMPAINT_COLOR_BRIGHT_MAGENTA bright magenta
14 TERMPAINT_COLOR_BRIGHT_CYAN bright cyan
15 TERMPAINT_COLOR_WHITE bright white
====== ============================== ====
.. _indexed-colors:
Indexed colors
..............
The next color space is :c:macro:`TERMPAINT_INDEXED_COLOR`. This is a indexed color space. For most terminals it has
256 colors. Some terminals only implement 88 colors though. Per convention the first 16 colors (0-15) are the same as
the named colors. Some terminals handle these differently in combination with the :c:macro:`TERMPAINT_STYLE_BOLD`
style. For terminals supporting 256 colors in the default palette the rest of the indices are divided in a 6x6x6 color
cube and a 23 step gray ramp (indices 232-255). The defaults are the color cube uses intensity levels of
[0, 95, 135, 175, 215, 255] and calculates the components as red is (index-16) / 36, green is (index-16) / 6) % 6 and
blue (index-16) % 6. The gray ramp uses the intensity levels of
[8, 18, 28, 38, 48, 58, 68, 78, 88, 98, 108, 118, 128, 138, 148, 158, 168, 178, 188, 198, 208, 218, 228, 238]. Of course
the index colors are redefinable so users might have a changed palette active.
For some terminal implementations using index colors leads to garbled display because not all terminals support parsing
the needed control sequences.
.. image:: color256.png
.. _rgb-colors:
RGB colors
..........
The last color space is :c:macro:`TERMPAINT_RGB_COLOR`. This is a direct color space which does not allow redefining
colors. A color is specified by red, green and blue intensities in the range 0 to 255. For example
``TERMPAINT_RGB_COLOR(255, 128, 64)``
For some terminal implementations using direct rgb colors leads to garbled display because not all terminals support
parsing the needed control sequences. Termpaint automatically translates RGB colors to indexed colors using the default
palette when terminal capability detection yields that the terminal can not handle them. This detection is not always
exact and can be switched to a more conservative mode by disabling the capability ``TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED``.
In the opposite direction promising the capability ``TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED`` disables translation to
index colors.
.. c:macro:: TERMPAINT_RGB_COLOR_OFFSET(red, green, blue)
A macro that returns a rgb color composed of the given values for red, green and blue. The value range
is 0 to 255 for each color component
Styles
------
Clusters may have one or more styles. The style changes how characters are displayed. The
:c:macro:`TERMPAINT_STYLE_INVERSE` style also applies to blank cells.
Styles can be enabled and disabled by using the :c:func:`termpaint_attr_set_style()` and
:c:func:`termpaint_attr_unset_style()` functions. These functions take one or more of the style macros combined with
bitwise or (``|``).
Attribute support varies with terminal implementation.
.. table:: Available styles
:align: left
=================== =========
Style Macro
=================== =========
bold :c:macro:`TERMPAINT_STYLE_BOLD`
inverse :c:macro:`TERMPAINT_STYLE_INVERSE`
italic :c:macro:`TERMPAINT_STYLE_ITALIC`
blink :c:macro:`TERMPAINT_STYLE_BLINK`
underline :c:macro:`TERMPAINT_STYLE_UNDERLINE`
double underline :c:macro:`TERMPAINT_STYLE_UNDERLINE_DBL`
curly underline :c:macro:`TERMPAINT_STYLE_UNDERLINE_CURLY`
strikethrough :c:macro:`TERMPAINT_STYLE_STRIKE`
overline :c:macro:`TERMPAINT_STYLE_OVERLINE`
=================== =========
Functions
---------
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:macro:: TERMPAINT_DEFAULT_COLOR
A Macro used to denote the terminals default color
.. c:macro:: TERMPAINT_NAMED_COLOR
A Macro used to denote the first of the named colors. For example use ``TERMPAINT_NAMED_COLOR + 1`` to denote red.
.. c:macro:: TERMPAINT_INDEXED_COLOR
A Macro used to denote the first indexed color. For example use ``TERMPAINT_NAMED_COLOR + 243`` to denote a mid gray.
.. c:macro:: TERMPAINT_RGB_COLOR(r, g, b)
A Macro used to denote the rgb direct colors. Parameters are in the range 0 to 255.
.. c:function:: termpaint_attr* termpaint_attr_new(unsigned fg, unsigned bg)
Creates a new attributes object with the foreground color ``fg`` and background color ``bg``. No styles will
be selected.
The application has to free this with :c:func:`termpaint_attr_free`.
.. c:function:: termpaint_attr* termpaint_attr_clone(termpaint_attr* attr)
Creates a new attributes object with the same settings as the attributes object passed in ``attr``.
The application has to free this with :c:func:`termpaint_attr_free`.
.. c:function:: void termpaint_attr_free(termpaint_attr* attr)
Frees a attributes object allocated with :c:func:`termpaint_attr_new()` or :c:func:`termpaint_attr_clone()`.
.. c:function:: void termpaint_attr_set_fg(termpaint_attr* attr, unsigned fg)
Set the foreground to be used when painting to ``fg``.
.. c:function:: void termpaint_attr_set_bg(termpaint_attr* attr, unsigned bg)
Set the background to be used when painting to ``bg``.
.. c:function:: void termpaint_attr_set_deco(termpaint_attr* attr, unsigned deco_color)
Set the decoration color to be used when painting to ``deco_color``.
.. c:macro:: TERMPAINT_STYLE_BOLD
Style the text in bold. `(widely supported) `__
Some terminal implementations change named colors in the range 0-7 to their bright variants when rendering bold text.
.. c:macro:: TERMPAINT_STYLE_ITALIC
Style the text in italic. `(widely supported) `__
.. c:macro:: TERMPAINT_STYLE_BLINK
Text should blink. `(support varies by terminal implementation) `__
.. c:macro:: TERMPAINT_STYLE_OVERLINE
Style the text with a overline. `(limited support in terminal implementations) `__
.. c:macro:: TERMPAINT_STYLE_INVERSE
Display the text with inverted foreground and background color. `(widely supported) `__
.. c:macro:: TERMPAINT_STYLE_STRIKE
Style the text in strikethrough. `(support varies by terminal implementation) `__
.. c:macro:: TERMPAINT_STYLE_UNDERLINE
Style the text with a single underline. `(widely supported) `__
If supported by the terminal emulator the underline uses the decoration color.
.. c:macro:: TERMPAINT_STYLE_UNDERLINE_DBL
Style the text with a double underline. `(limited support in terminal implementations) `__
If supported by the terminal emulator the underline uses the decoration color.
.. c:macro:: TERMPAINT_STYLE_UNDERLINE_CURLY
Style the text with a curly underline. `(limited support in terminal implementations) `__
If supported by the terminal emulator the underline uses the decoration color.
.. c:function:: void termpaint_attr_set_style(termpaint_attr* attr, int bits)
Adds the styles given in ``bits`` to the attributes.
.. c:function:: void termpaint_attr_unset_style(termpaint_attr* attr, int bits)
Removes the styles given in ``bits`` to the attributes.
.. c:function:: void termpaint_attr_reset_style(termpaint_attr* attr)
Removes all previously set styles.
.. c:function:: void termpaint_attr_set_patch(termpaint_attr* attr, _Bool optimize, const char *setup, const char * cleanup)
This function allows to use additional attributes for rendering that are not otherwise explicitly supported.
.. warning:: This is a low level feature with potential to garble the whole terminal rendering. Use with care.
Allows setting escape sequences to be output before (``setup``) and after (``cleanup``) rendering each cluster with
this style. If ``optimize`` is set, do not use ``setup`` and ``cleanup`` between clusters that have the exact same
patch.
The caller is responsible to ensure that the patches don't break rendering. Setup is output after the "select graphics
rendition" escape sequence right before the text of the cluster is output. If ``optimize`` is not set cleanup is output
directly following the text of the cluster.
If ``optimize`` is true, the setup sequence must not contain "select graphics rendition" sequences because the
rendering resets SGR state between clusters if styles change in a display run.
termpaint-0.3.1/doc/callback-event-handling.c 0000664 0000000 0000000 00000010163 14773035472 0021101 0 ustar 00root root 0000000 0000000 // Feel free to copy from this example to your own code
// SPDX-License-Identifier: 0BSD OR BSL-1.0 OR MIT-0
#include
#include
#include
// snippet-header-start
#include "termpaint.h"
#include "termpaintx.h"
// snippet-header-end
// snippet-globals-start
termpaint_terminal *terminal;
termpaint_surface *surface;
void (*current_callback)(void *user_data, termpaint_event* event);
void *current_data;
// snippet-globals-end
// snippet-callback-start
void event_callback(void *userdata, termpaint_event *event) {
(void)userdata;
if (current_callback) {
current_callback(current_data, event);
}
}
// snippet-callback-end
// snippet-quit-data-start
typedef struct quit_dialog_ {
void (*saved_callback)(void *user_data, termpaint_event* event);
void *saved_data;
bool *result;
} quit_dialog;
// snippet-quit-data-end
// snippet-quit-callback-start
void quit_dialog_callback(void *userdata, termpaint_event *event) {
quit_dialog* dlg = userdata;
if (!event) {
return;
}
if (event->type == TERMPAINT_EV_CHAR) {
if (event->c.length == 1
&& (event->c.string[0] == 'y' || event->c.string[0] == 'Y')) {
current_data = dlg->saved_data;
current_callback = dlg->saved_callback;
*dlg->result = true;
free(dlg);
current_callback(current_data, NULL);
return;
}
if (event->c.length == 1
&& (event->c.string[0] == 'n' || event->c.string[0] == 'N')) {
current_data = dlg->saved_data;
current_callback = dlg->saved_callback;
*dlg->result = false;
free(dlg);
current_callback(current_data, NULL);
return;
}
}
if (event->type == TERMPAINT_EV_CHAR || event->type == TERMPAINT_EV_KEY) {
termpaint_surface_write_with_colors(surface, 20, 5,
"Please reply with either 'y' for yes or 'n' for no.",
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
termpaint_terminal_flush(terminal, false);
}
}
// snippet-quit-callback-end
// snippet-quit-ctor-start
void quit_dialog_start(bool *result) {
quit_dialog* dlg = calloc(1, sizeof(quit_dialog));
dlg->saved_data = current_data;
dlg->saved_callback = current_callback;
dlg->result = result;
current_data = dlg;
current_callback = quit_dialog_callback;
int fg = TERMPAINT_DEFAULT_COLOR;
int bg = TERMPAINT_DEFAULT_COLOR;
termpaint_surface_write_with_colors(surface, 20, 4, "Really quit? (y/N)",
fg, bg);
termpaint_terminal_flush(terminal, false);
}
// snippet-quit-ctor-end
void main_screen_callback(void *userdata, termpaint_event *event) {
if (!event) {
termpaint_surface_write_with_colors(surface,
0, 0,
"There is really nothing else to do than quit!",
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
termpaint_terminal_flush(terminal, false);
quit_dialog_start(userdata);
}
}
int main(int argc, char **argv) {
(void)argc; (void)argv;
termpaint_integration *integration;
integration = termpaintx_full_integration_setup_terminal_fullscreen(
"+kbdsig +kbdsigint",
event_callback, NULL,
&terminal);
surface = termpaint_terminal_get_surface(terminal);
termpaint_surface_clear(surface,
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
termpaint_surface_write_with_colors(surface,
0, 0,
"Hello World",
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
termpaint_terminal_flush(terminal, false);
bool quit;
current_callback = main_screen_callback;
current_data = &quit;
quit_dialog_start(&quit);
// snippet-main-start
while (!quit) {
if (!termpaintx_full_integration_do_iteration(integration)) {
// some kind of error
break;
}
}
termpaint_terminal_free_with_restore(terminal);
// snippet-main-end
return 0;
}
termpaint-0.3.1/doc/check.py 0000775 0000000 0000000 00000012705 14773035472 0015736 0 ustar 00root root 0000000 0000000 #! /usr/bin/python3
import json
import sys
import os
d = json.load(open('_build/json/genindex.fjson', 'r'))
c_functions = []
c_macros = []
c_types = []
c_enums = []
for letter in d['genindexentries']:
for entry in letter[1]:
display_name = entry[0]
if display_name.endswith(' (C function)'):
c_functions.append(display_name[:-13])
elif display_name.endswith(' (C macro)'):
c_macros.append(display_name[:-10])
elif display_name.endswith(' (C type)'):
c_types.append(display_name[:-9])
elif display_name.endswith(' (C enum)'):
c_enums.append(display_name[:-9])
elif display_name.endswith(' (C enumerator)'):
pass # ignore
else:
print("can not guess type of index entry: ", display_name)
# keys
c_functions.extend(['termpaint_input_enter', 'termpaint_input_space', 'termpaint_input_tab', 'termpaint_input_backspace', 'termpaint_input_context_menu', 'termpaint_input_delete', 'termpaint_input_end', 'termpaint_input_home', 'termpaint_input_insert', 'termpaint_input_page_down', 'termpaint_input_page_up', 'termpaint_input_arrow_down', 'termpaint_input_arrow_left', 'termpaint_input_arrow_right', 'termpaint_input_arrow_up', 'termpaint_input_numpad_divide', 'termpaint_input_numpad_multiply', 'termpaint_input_numpad_subtract', 'termpaint_input_numpad_add', 'termpaint_input_numpad_enter', 'termpaint_input_numpad_decimal', 'termpaint_input_numpad0', 'termpaint_input_numpad1', 'termpaint_input_numpad2', 'termpaint_input_numpad3', 'termpaint_input_numpad4', 'termpaint_input_numpad5', 'termpaint_input_numpad6', 'termpaint_input_numpad7', 'termpaint_input_numpad8', 'termpaint_input_numpad9', 'termpaint_input_escape', 'termpaint_input_f1', 'termpaint_input_f2', 'termpaint_input_f3', 'termpaint_input_f4', 'termpaint_input_f5', 'termpaint_input_f6', 'termpaint_input_f7', 'termpaint_input_f8', 'termpaint_input_f9', 'termpaint_input_f10', 'termpaint_input_f11', 'termpaint_input_f12'])
c_functions.extend([]) # intentionally undocumented
c_types.extend(['termpaint_integration_private']) # intentionally undocumented
c_types.extend(['termpaint_logging_func']) # helper to workaround problems in inline type specification
sys.path.insert(0, "/opt/qtcreator-build/llvm-10/clang/bindings/python/")
os.environ['CLANG_LIBRARY_PATH'] = '/opt/qtcreator-build/llvm-10-build/lib'
from clang.cindex import CursorKind
from clang.cindex import Index, TranslationUnit
from clang.cindex import SourceLocation, SourceRange
from clang.cindex import TokenKind, TokenGroup
import clang.cindex
clang.cindex.Config.set_library_path('/opt/qtcreator-build/llvm-10-build/lib')
function_names_from_source = []
typedef_names_from_source = []
enum_names_from_source = []
macro_names_from_source = []
def get_from_header(header_name):
expected_basename = header_name.split('/')[-1]
index = Index.create()
tu = index.parse(header_name, options=TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD)
# | TranslationUnit.PARSE_SKIP_FUNCTION_BODIES
for cursor in tu.cursor.get_children():
#print(cursor.kind)
basename = str(cursor.location.file).split('/')[-1]
if basename != expected_basename: continue
#print(cursor.kind, cursor.displayname)
if cursor.kind == CursorKind.FUNCTION_DECL:
function_names_from_source.append(cursor.spelling)
sig = cursor.result_type.spelling + ' ' + cursor.spelling + '('
args = []
for arg in cursor.get_children():
if arg.kind != CursorKind.PARM_DECL: continue
args.append(arg.type.spelling + ' ' + arg.spelling)
#if cursor.type.is_function_variadic():
# args.append('...')
sig += ', '.join(args) + ')'
#print(sig)
if cursor.kind == CursorKind.TYPEDEF_DECL:
typedef_names_from_source.append(cursor.spelling)
if cursor.kind == CursorKind.ENUM_DECL:
enum_names_from_source.append(cursor.spelling)
if cursor.kind == CursorKind.MACRO_DEFINITION and not cursor.spelling.endswith('_INCLUDED'):
macro_names_from_source.append(cursor.spelling)
get_from_header('../termpaint.h')
get_from_header('../termpaint_event.h')
get_from_header('../termpaint_image.h')
get_from_header('../termpaint_input.h')
get_from_header('../termpaintx.h')
get_from_header('../termpaintx_ttyrescue.h')
def filter(fn):
return ( (fn.endswith('_mustcheck') and fn[:-10] in function_names_from_source)
or (fn.endswith('_or_nullptr') and fn[:-11] in function_names_from_source))
macro_names_from_source = [name for name in macro_names_from_source if name not in ('_tERMPAINT_PUBLIC', 'TERMPAINTP_CAST')]
function_names_from_source = [fn for fn in function_names_from_source if not filter(fn)]
#print("undocumented functions: ", set(function_names_from_source) - set(c_functions))
#print("undocumented macros: ", set(macro_names_from_source) - set(c_macros))
#print("undocumented types: ", set(typedef_names_from_source) - set(c_types))
#print("enums: ", enum_names_from_source)
#print("number of items: ", len(function_names_from_source) + len(macro_names_from_source) + len(typedef_names_from_source) + len(enum_names_from_source))
for i in (list(set(function_names_from_source) - set(c_functions))
+ list(set(macro_names_from_source) - set(c_macros))
+ list(set(typedef_names_from_source) - set(c_types))
+ list(set(enum_names_from_source) - set(c_enums))):
print(i)
termpaint-0.3.1/doc/color256.png 0000664 0000000 0000000 00000004453 14773035472 0016366 0 ustar 00root root 0000000 0000000 PNG
IHDR ? :P PLTE \\ _ _ _ __ _ _ _ _ ׇ _ __ _ _ _ ___ ____________ _____ׇ_ _ _ ______ _ׇ _ _ ______ _ׇ _ ׇ ׯ _ ___ׇ_ׯ__ _ׇׯׇ _ _ ______ _ׇ _ ׯ _ _ ׯ_ _____ׯ__ _______ ______ _ׯׇ ׇ_ׇׇׇׇ _ _ׯׯ ׯ_ׯׯׯׯ _ _ׇׯׯ _ׇׯ _ׇׯ _ׯ __ &&&000:::DDDNNNXXXbbblllvvvя bKGD H pHYs tIME", IDATxccW {nۭm۶m۶ݭm۶m۶m[dߛپO?;7''rD$I$I
a`X`D#A_( 3 ~$i"W_H
Kmlּ&^$c
Z[s ~~t~~ O~J}~>c2% gRzr.cOJ$4q6ډ3Cr5&4vwt[͆O%.vKjSگk^ׅ CP{
hKs!{
gk;T\k M /4i]%"lxW$j0*0&ēǂa ƃ!<L0 L
g?~g?ٯ`r`j'Ot0= 3Bl Bmʟ!6eNBߐ:W:4M99Me^cݽ衅W e\,"⣇J9PoS@5;KHu(2WO?~=jumv.)e^e ON:*/Ij'7~I_}_mʻF+\!69)1B_6 ѣ/^y+k>SϠeۗU${H
/bHZ49^M;p |0 ap8 >p$ G1g?~g?~_1qp< 'IO>NS48 xp
p ~g?~gb· B.K |)\p%\g?~g?~7p
A`?~g?~$I$I! sk{~g~wog?~g?~$I$N=jk IENDB` termpaint-0.3.1/doc/conf.py 0000664 0000000 0000000 00000004374 14773035472 0015606 0 ustar 00root root 0000000 0000000 # Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# http://www.sphinx-doc.org/en/master/config
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))
# -- Project information -----------------------------------------------------
project = 'Termpaint'
copyright = '2020, Martin Hostettler'
author = 'Martin Hostettler'
# The full version, including alpha/beta/rc tags
release = '0.3.0'
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
highlight_language = 'c'
nitpick_ignore = [
('c:identifier', 'FILE'),
('c:identifier', 'termios'),
('c:identifier', 'uint16_t'),
('c:identifier', 'uint32_t'),
]
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'alabaster'
html_theme_options = {
'page_width': '1040px',
'sidebar_width': '190px',
'github_user': 'termpaint',
'github_repo': 'termpaint',
'github_banner': True,
}
html_show_copyright = False
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
termpaint-0.3.1/doc/details.rst 0000664 0000000 0000000 00000012074 14773035472 0016462 0 ustar 00root root 0000000 0000000 Technical details
=================
.. _resync:
Handling of ambiguous input
---------------------------
Terminal to application communicating doesn't use a prefix free
encoding. For example the escape key sends just ASCII 0x1b, but many function
key sequences also begin with ASCII 0x1b. As the terminal communication is just
a stream of bytes the library needs to use some strategy to decide when no
further input is considered part of the input sequence.
Many terminal interface libraries use timeouts to disambiguate input. Which on
one hand makes behavior timing dependent and too large timeouts interfere with
using ESC followed by any other key.
Termpaint doesn't use timeouts in the traditional way. Instead when termpaint
encounters a sequence that needs disambiguation, it sends a request to the
terminal which produces a fixed reply that allows to disambiguate the sequence.
In practical terms the sequence used is ``ESC[5n`` to which the terminal replies
``ESC[0n``.
The concrete implementation uses a short delay before sending ``ESC[5n`` to
reduce overhead. It also only ever keeps one such request in flight at one time.
.. _safety:
Safety
------
There are various rules an application has to follow to safely interact with
functions in termpaint.
Parameters
----------
* unless otherwise specified all pointers need to point to valid objects of
their type
* pointers to opaque structures always need to point to a initialized and
valid object. (Exceptions are of course functions that initialize the
objects)
Life times
..........
Objects derived from the terminal object need to have a bounded lifetime that
does not exceed the lifetime of the terminal object.
The application is responsible for freeing all subobjects before freeing the
terminal object.
Integrations have to take care not to call into the terminal object after it
was freed.
Threading and signals
.....................
No function in termpaint is async signal safe. Applications must cache all
needed information for signal handlers themselves.
All objects that are created (transitively) from a terminal and the
terminals integration need to be handled as one item for threading. This
whole collection of objects may only be called from a one thread at a time.
Switching the thread that calls into this collection needs to be mediated by
a C happens-before relation.
Independent terminal instances can be used without interfering with each other.
.. _incremental-update:
Terminal update optimization
----------------------------
Each call to :c:func:`termpaint_terminal_flush` takes a copy of the just
flushed primary surface. If the next call to ``flush`` does not specify
a full redraw, only cells are redrawn that differ from the copy made in
the previous call.
.. _malloc-failure:
Environments that need to handle malloc failure
-----------------------------------------------
A restricted subset of termpaint can be used in environments that need to
handle malloc failure gracefully.
The default mode of operation of termpaint is to abort() on allocation
failure for ease of usage and to avoid cluttering code using termpaint
with checks. For many applications that are not carefully written to
handle allocation failure this is a reasonable tradeoff. For applications
that are written carefully enough to handle allocation failures there is
an alternative mode, that avoids aborting.
For these applications three major differences in usage are needed.
The first difference is that for all functions where a variant ending with
``_or_nullptr`` or ``_mustcheck`` is offered the application needs to call
these variants. These signal via a return value of NULL or false that
memory allocation failed. The application can try to work without their
effects or try calling them again later. Consult the header files for
which functions need these variants.
The next difference is that applications need to call
:c:func:`termpaint_terminal_glitch_on_out_of_memory` to switch termpaint
to a mode where it does not abort, but potentially misrenders output when
memory allocation fails in code paths that can't sensibly report an error.
The major parts where this can happen is when writing strings that need
more than 8 byte of utf8 encoded characters per cell (i.e. stacks of
composing characters or complex emoji sequences) or when using
:c:func:`termpaint_attr_set_patch`.
The last difference is that the application may only use a limited subset
of termpaint.
Currently there are the following known restrictions:
* :c:func:`termpaint_surface_copy_rect` must not be used with the same
surface for source and destination. As workaround preallocate a
surface to use as an intermediate surface for such copy operations.
* termpaintx is not yet allocation failure safe.
Some parts of termpaint like terminal type auto-detection and management
of the restore sequence use preallocated memory to avoid memory allocation
failures in many code paths. The preallocations might not be large enough
if a terminal sends excessive amounts of identifying data or the application
uses an extremely high amount of setup (i.e. more colors slots than predefined).
termpaint-0.3.1/doc/events.rst 0000664 0000000 0000000 00000033067 14773035472 0016346 0 ustar 00root root 0000000 0000000 Events
======
Terminal input is translated to events. The application handles the events by implementing a event callback and setting
it on the terminal object by using the :c:func:`termpaint_terminal_set_event_cb()` function.
The primary input events are character events, key events and mouse events.
Each event has a ``type`` which describes what kind of event is emitted. An application should ignore events of types
that the application does not know how to handle, as from time to time new events will be added.
.. _character event:
Character events
----------------
Character events are emitted when the user presses a key that has a printable character associated. The ``type`` field
will be set to :c:macro:`TERMPAINT_EV_CHAR`. The input character is described by an utf8 string (not null terminated)
that is available as ``c.string`` with length ``c.length``. Additionally the field ``c.modifier`` contains a bit field
describing the modifier keys held while the character was input.
The space key and enter key are handled as key events as described in the following section.
.. _key event:
Key events
----------
Key events are emitted for key presses on non character keys like space, enter, the edit keys and function keys. The
``type`` field will be set to :c:macro:`TERMPAINT_EV_KEY`. The key is described by the ``key.atom`` field which can be
used in two ways. Together with ``key.length`` it contains a (not null terminated) string naming the key. Additionally
``key.atom`` can be compared as pointer to the result of the termpaint_input_* functions that return a unique pointer
value that can be used instead of string comparison.
See :doc:`keys` for a complete list of keys.
Additionally the field ``c.modifier`` contains a bit field
describing the modifier keys held while the character was input.
.. _modifiers:
Modifiers
---------
Modifiers is a bit flag of combinations of the following:
.. c:macro:: TERMPAINT_MOD_SHIFT
The key was pressed while the shift key was held.
.. c:macro:: TERMPAINT_MOD_CTRL
The key was pressed while the ctrl key was held.
.. c:macro:: TERMPAINT_MOD_ALT
The key was pressed while the alt key was held.
.. c:macro:: TERMPAINT_MOD_ALTGR
The key was pressed while the shift alt-gr key (alternate graphics) was held.
.. _mouse event:
Not all terminals support reporting all modifiers with each key. Generally the function keys
and arrow keys have better modifier reporting that the printable characters.
Mouse events
------------
Many terminals have optional mouse reporting modes. If these are supported and activated by calling
:c:func:`termpaint_terminal_set_mouse_mode` input events for mouse clicks and possibly more events will
be produced.
The ``type`` field will be set to :c:macro:`TERMPAINT_EV_KEY`.
Mouse events consist of ``x`` and ``y`` coordinates of the event. ``modifier`` held while the event was
generated and an ``action`` that describes if the event was a click, release or a movement event.
For click events the ``button`` number is available.
.. _misc-events:
Misc events
-----------
Various non keyboard related terminal events that don't need additional data.
.. c:function:: const char *termpaint_input_focus_in(void)
The terminal has received focus. Terminal support varies and is opt-in. Focus
change events can be requested using :c:func:`termpaint_terminal_request_focus_change_reports`.
String value: ``FocusIn``
.. c:function:: const char *termpaint_input_focus_out(void)
The terminal has lost focus. Terminal support varies and is opt-in. Focus
change events can be requested using :c:func:`termpaint_terminal_request_focus_change_reports`.
String value: ``FocusOut``
.. c:function:: const char *termpaint_input_paste_begin(void)
If enabled in the terminal pasted text is bracketed by paste begin and paste end markers.
If translation of the whole sequence to paste events is disabled using :c:func:`termpaint_input_handle_paste`
then this misc event is emitted on paste start.
Terminal support varies and is opt-in.
String value: ``PasteBegin``
.. c:function:: const char *termpaint_input_paste_end(void)
If enabled in the terminal pasted text is bracketed by paste begin and paste end markers.
If translation of the whole sequence to paste events is disabled using :c:func:`termpaint_input_handle_paste`
then this misc event is emitted on paste end.
Terminal support varies and is opt-in.
String value: ``PasteEnd``
.. c:function:: const char *termpaint_input_i_resync(void)
This misc event is emitted when the input parser was resynchronized by
requesting a device status report due to a incomplete terminal sequence.
See :ref:`resync` for details.
String value: ``i_resync``
Main event types
----------------
.. c:macro:: TERMPAINT_EV_CHAR
A :ref:`character event ` was sent by the terminal.
.. c:macro:: TERMPAINT_EV_KEY
A :ref:`key event ` was sent by the terminal.
.. c:macro:: TERMPAINT_EV_PASTE
The terminal sent a clipboard paste event.
.. c:macro:: TERMPAINT_EV_AUTO_DETECT_FINISHED
The auto detection phase was finished. The application can now create it's user interface.
See :ref:`terminal-setup`.
The event does not contain additional data.
.. c:macro:: TERMPAINT_EV_MOUSE
A :ref:`mouse event` was sent by the terminal.
.. c:macro:: TERMPAINT_EV_MISC
Other simple terminal events.
.. c:macro:: TERMPAINT_EV_REPAINT_REQUESTED
Termpaint acquired additional data and a repaint could improve the rendering of the user interface. Currently used when
after :c:func:`termpaint_terminal_set_color` has made sure the color can be restored to it's original value on restore.
The event does not contain additional data.
Other event types
-------------------
.. c:macro:: TERMPAINT_EV_UNKNOWN
An unknown event was sent by the terminal.
The event does not contain additional data.
.. c:macro:: TERMPAINT_EV_OVERFLOW
The internal parsing buffer was discarded because a sequence was to long to fit.
The event does not contain additional data.
.. c:macro:: TERMPAINT_EV_INVALID_UTF8
The terminal sent invalid utf8 encoded data.
.. c:macro:: TERMPAINT_EV_CURSOR_POSITION
The terminal sent a cursor position report.
.. c:macro:: TERMPAINT_EV_MODE_REPORT
The terminal sent a mode report.
.. c:macro:: TERMPAINT_EV_COLOR_SLOT_REPORT
The terminal sent a color report.
.. c:macro:: TERMPAINT_EV_RAW_PRI_DEV_ATTRIB
The terminal sent a primary device attributes report.
.. c:macro:: TERMPAINT_EV_RAW_SEC_DEV_ATTRIB
The terminal sent a secondary device attributes report.
.. c:macro:: TERMPAINT_EV_RAW_3RD_DEV_ATTRIB
The terminal sent a tertiary device attributes report.
.. c:macro:: TERMPAINT_EV_RAW_DECREQTPARM
The terminal sent a dec terminal parameters report.
.. c:macro:: TERMPAINT_EV_PALETTE_COLOR_REPORT
The terminal sent a palette color report.
.. c:macro:: TERMPAINT_EV_RAW_TERMINFO_QUERY_REPLY
The terminal sent a report for a ``ESCP+????ESC\\`` query.
.. c:macro:: TERMPAINT_EV_RAW_TERM_NAME
The terminal sent a report for a ``ESC[>q`` query.
Termpaint only uses event types >= 0. If the design of an application needs
application internal codes that coexist with termpaint event types in the same
``int``-typed variable, it may use negative numbers for these.
The event structure
-------------------
.. c:type:: termpaint_event
::
int type;
The type of the events. Depending on the value of ``type`` different parts of the event contain valid data.
If ``type`` is :c:macro:`TERMPAINT_EV_CHAR` or :c:macro:`TERMPAINT_EV_INVALID_UTF8`:
::
struct {
unsigned length;
const char *string;
int modifier;
} c;
``string`` and ``length`` together describe a (non null terminated) string with the raw data from the terminal.
``modifiers`` describes the :ref:`modifiers` held.
If ``type`` is :c:macro:`TERMPAINT_EV_CHAR` this describes a key press. If ``type`` is
:c:macro:`TERMPAINT_EV_INVALID_UTF8` the terminal sent a invalidly encoded utf8 sequence.
If ``type`` is :c:macro:`TERMPAINT_EV_KEY`:
::
struct {
unsigned length;
const char *atom;
int modifier;
} key;
``atom`` and ``length`` together describe which (non null terminated) key from the table :doc:`keys` was pressed.
Alternatively ``atom`` can directly compared to the one of the pointers returned by one of the termpaint_input_*
functions. ``modifiers`` describes the :ref:`modifiers` held.
If ``type`` :c:macro:`TERMPAINT_EV_MOUSE`:
::
struct {
int x;
int y;
int raw_btn_and_flags;
int action;
int button; // button == 3 means release with unknown button
int modifier;
} mouse;
Each mouse event has a position described by ``x``, ``y`` and the state of the keyboard :ref:`modifiers`
held is made available in ``modifier``.
``action`` describes if the event was a button press, button release or mouse pointer move event.
Which of these events are sent depends on the mouse mode of the terminals. See :c:func:`termpaint_terminal_set_mouse_mode`
for details.
For mouse press events the number of the pressed button is available as ``button``. Mouse release and move events
have limited support for this information depending on the terminal. Left, middle and right buttons have the numbers
0, 1 and 2 respectively. Button number 3 is used by terminals when no button is held or the button information is not
available.
.. c:macro:: TERMPAINT_MOUSE_PRESS
The button ``button`` was pressed.
.. c:macro:: TERMPAINT_MOUSE_RELEASE
A mouse button was released. Depending on the terminal ``button`` is either 3 or the number of the
just release mouse button.
.. c:macro:: TERMPAINT_MOUSE_MOVE
The mouse cursor was moved.
``raw_btn_and_flags`` contains a raw and undecoded value from the terminal that contains information from which
``modifiers`` and ``button`` was interpreted. It's available for not yet fully supported extended event information
from the terminal.
If ``type`` is :c:macro:`TERMPAINT_EV_PASTE`:
::
struct {
unsigned length;
const char *string;
_Bool initial;
_Bool final;
} paste;
A paste event. As termpaint does not buffer the pasted characters a paste from the terminal generates many fragmented
events. ``initial`` is true if this event belongs to the start of a paste operation and ``final`` is true if this
event marks the end of the paste operation.
``string`` and ``length`` together describe a (non null terminated) string with a fragment of the pasted characters.
The application should be prepared to get empty fragments and fragments with one or multiple characters. Details how
the events are fragmented are subject to change in future versions of the library.
If ``type`` is :c:macro:`TERMPAINT_EV_MISC`:
::
struct {
unsigned length;
const char *atom;
} misc;
A misc event. Available value for atom are described in `Misc Events`_.
``atom`` can directly compared to the one of the pointers returned by one of the functions described there.
Alternatively ``atom`` and ``length`` together form a (non null terminated) string that can compared to one of
the strings also described in that section.
If ``type`` is :c:macro:`TERMPAINT_EV_CURSOR_POSITION`:
::
struct {
int x;
int y;
_Bool safe;
} cursor_position;
A cursor position report. ``x`` and ``y`` contain the cell coordinates of the reported cursor position.
If ``safe`` is true the cursor position report was in a format that is not ambiguous with a keyboard event.
See :c:func:`termpaint_input_expect_cursor_position_report` for handling of ambiguous cursor position events.
If ``type`` is :c:macro:`TERMPAINT_EV_MODE_REPORT`
::
struct {
int number;
int kind;
int status;
} mode;
The terminal send a report for a terminal mode query. If ``kind`` is 1 the report is for a "private" mode, otherwise
it's for a non private mode. ``number`` specifies the mode number. ``status`` is the status of the mode and contains
a value from the following list:
0
unknown mode
3
mode is set
4
mode is reset
If ``event`` is :c:macro:`TERMPAINT_EV_RAW_PRI_DEV_ATTRIB`, :c:macro:`TERMPAINT_EV_RAW_SEC_DEV_ATTRIB`,
:c:macro:`TERMPAINT_EV_RAW_3RD_DEV_ATTRIB`, :c:macro:`TERMPAINT_EV_RAW_DECREQTPARM`,
:c:macro:`TERMPAINT_EV_RAW_TERMINFO_QUERY_REPLY` or :c:macro:`TERMPAINT_EV_RAW_TERM_NAME`:
::
struct {
unsigned length;
const char *string;
} raw;
The mostly raw report from the terminal is contained in ``string`` and ``length`` which together describe
a (non null terminated) string.
If ``type`` is :c:macro:`TERMPAINT_EV_COLOR_SLOT_REPORT`:
::
struct {
int slot;
const char *color;
unsigned length;
} color_slot_report;
A report for a query of a global terminal color was received. ``slot`` contains the number of the slot and
``color`` and ``length`` together describe a (non null terminated) string which contains the color data reported
by the terminal.
If ``type`` is :c:macro:`TERMPAINT_EV_PALETTE_COLOR_REPORT`:
::
struct {
int color_index;
const char *color_desc;
unsigned length;
} palette_color_report;
A report for a query of a palette terminal color was received. ``color_index`` contains index of the color in the
palette and ``color`` and ``length`` together describe a (non null terminated) string which contains the color
data reported by the terminal.
termpaint-0.3.1/doc/getting-started.c 0000664 0000000 0000000 00000003234 14773035472 0017552 0 ustar 00root root 0000000 0000000 // Feel free to copy from this example to your own code
// SPDX-License-Identifier: 0BSD OR BSL-1.0 OR MIT-0
#include
// snippet-header-start
#include "termpaint.h"
#include "termpaintx.h"
// snippet-header-end
// snippet-callback-start
void event_callback(void *userdata, termpaint_event *event) {
bool *quit = userdata;
if (event->type == TERMPAINT_EV_CHAR) {
if (event->c.length == 1 && event->c.string[0] == 'q') {
*quit = true;
}
}
if (event->type == TERMPAINT_EV_KEY) {
if (event->key.atom == termpaint_input_escape()) {
*quit = true;
}
}
}
// snippet-callback-end
int main(int argc, char **argv) {
(void)argc; (void)argv;
// snippet-main-start
termpaint_integration *integration;
termpaint_terminal *terminal;
termpaint_surface *surface;
bool quit = false;
integration = termpaintx_full_integration_setup_terminal_fullscreen(
"+kbdsig +kbdsigint",
event_callback, &quit,
&terminal);
surface = termpaint_terminal_get_surface(terminal);
termpaint_surface_clear(surface,
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
termpaint_surface_write_with_colors(surface,
0, 0,
"Hello World",
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
termpaint_terminal_flush(terminal, false);
while (!quit) {
if (!termpaintx_full_integration_do_iteration(integration)) {
// some kind of error
break;
}
}
termpaint_terminal_free_with_restore(terminal);
// snippet-main-end
return 0;
}
termpaint-0.3.1/doc/getting-started.rst 0000664 0000000 0000000 00000031514 14773035472 0020142 0 ustar 00root root 0000000 0000000 Getting started
===============
Termpaint is a low level terminal interface library. The output model is a grid
of character cells with :ref:`attributes` specifying colors and
style (like bold or underline).
Input from the terminal is passed into the library which then calls a
user-provided event callback with e.g. character or key press events.
The core of termpaint does not do any operating system or environment specific
I/O. In the general case the application provides an integration pointer and
callbacks for all terminal I/O. This integration can connect to an existing
event loop or just wrap blocking terminal I/O.
For applications that deal with any kind of asynchronous events, apart from the
terminal, it's recommended to use a custom integration or an external integration
into an general event loop. But for simple applications that only deal with
synchronous data sources termpaint ships with a very simplistic sample
integration in a add-on called :doc:`termpaintx`. This integration helps to get
started quickly for simple applications. Let's start with a "Hello World" style
application.
Hello world
-----------
First you need to include the pkg-config dependency named ``termpaint`` into
your application's build. Next include the needed headers into your source:
.. literalinclude:: getting-started.c
:caption: includes
:start-after: // snippet-header-start
:end-before: // snippet-header-end
The most code is for the main function:
.. literalinclude:: getting-started.c
:caption: main code
:linenos:
:dedent: 4
:start-after: // snippet-main-start
:end-before: // snippet-main-end
This code starts with a few variables needed later. ``integration`` stores a
pointer to the :c:type:`integration object` needed
after initialization to run keyboard
input handling. ``terminal`` is used for interacting with the terminal as a
whole and ``surface`` for interaction with the character cell grid. Finally
``quit`` is used for communication between the event handler (see below) and
the loop waiting in the main function.
The first call uses :c:func:`termpaintx_full_integration_setup_terminal_fullscreen()`
to setup termpaint for full screen usage with the simple termpaintx
integration. Its first arguement is a string with
:ref:`options for termpaint` and
:ref:`options for termpaintx`, followed by
the event callback and it's data pointer. The last parameter is an out-parameter
and together with the return value they produce the pointers to the integration
object and the terminal object.
The following line extracts the pointer to the primary surface of the terminal
object. Surfaces in termpaint are objects that represent a character cell grid
that have functions to allow writing text.
The next line clears the whole primary surface (which later is transferred to
the terminal) with the given colors. It takes two colors because some terminals
behave oddly if cleared space has the same foreground and background color set [#defcol]_.
When two colors are specified in termpaint the order is always foreground color
and then background color. In this example the :ref:`default colors`
are used. These are special colors defined by the terminal. Additionally
:ref:`named`, :ref:`indexed`
and :ref:`rgb` colors are available.
:c:func:`termpaint_surface_write_with_colors` places text on the surface. It takes
the position for the text to start, the text itself (in utf-8) and the colors.
In termpaint coordinates are always 0-based and start in the upper-left corner.
The next line actually displays the content of the primary surface by calling
:c:func:`termpaint_terminal_flush()`.
The code that follows waits for the user to press ``q`` or the escape
key. :c:func:`termpaintx_full_integration_do_iteration` waits for input from
the terminal and lets termpaint process the data into events.
For deciding if the input matches this example uses the event callback:
.. literalinclude:: getting-started.c
:caption: event callback
:linenos:
:start-after: // snippet-callback-start
:end-before: // snippet-callback-end
This is a very simple callback only suitable for the example. Termpaint uses
:doc:`events of various types`. But the most important events are key
and character events. :ref:`Character events ` (``TERMPAINT_EV_CHAR``)
are emitted for printable characters like letters. :ref:`Key events `
(``TERMPAINT_EV_KEY``) are for other keys like function keys, enter or space.
Both additionally contain a bitflag that describes modifiers like alt and ctrl
that have been held down while pressing the key. The strings are not
nul-terminated. For key events the ``atom`` field can either be used as a string
or directly compared to the return of functions like ``termpaint_input_escape()``.
See :doc:`keys` for a complete list of keys.
Finally before termination the application :c:func:`termpaint_terminal_free_with_restore()`
should be called to restore the terminal to it's normal state.
See :download:`getting-started.c` for the whole source of this example.
Input handling strategies
-------------------------
Synchronous usage
.................
Termpaint uses an event callback based design for handling input events. This fits
well into designs which use a central event processing loop but out of the box it
does not fit well for code that wants to synchronously wait for input in many
places while processing, e.g. a usage styles where a menu or such is implemented by
a function that only returns after the user has completed interacting with it.
For such synchronous usage it's recommended to use an callback that just adds
events to a application specific queue of events. And then implement a function
that passes input from the terminal to termpaint until a new event appears.
In this way the application can also filter out events, it does not need, in these
functions. As termpaint tries to avoid allocations in steady state operation,
the event callback has to copy all needed data out of the original event to a
safe place.
First we need some data structures and variables to save the events:
.. literalinclude:: sync-event-handling.c
:linenos:
:start-after: // snippet-type-start
:end-before: // snippet-type-end
Here the key or character is represented by a freshly allocated nul-terminated string.
The events are copied into this structure in the event handler:
.. literalinclude:: sync-event-handling.c
:linenos:
:start-after: // snippet-callback-start
:end-before: // snippet-callback-end
In this case only key or character events are translated, all other events are
filtered out. For the events the type, string and modifiers are copied and the
new event is added to a linked list.
Next we need a function for the application to call to wait for the next event:
.. literalinclude:: sync-event-handling.c
:linenos:
:start-after: // snippet-wait-start
:end-before: // snippet-wait-end
The ``key_wait`` function either returns an already queued event or if
no event is queued it calls :c:func:`termpaintx_full_integration_do_iteration`
to wait for terminal data and process it. As soon as enough data is read and
processed to give one or more suitable events it stops waiting for data and
returns the first event. To easy usage this implementation internally handles
freeing the last returned event in the next ``key_wait`` call.
Now the application can synchronously wait for events like this:
.. literalinclude:: sync-event-handling.c
:linenos:
:dedent: 4
:start-after: // snippet-main-start
:end-before: // snippet-main-end
Remember to flush the primary surface to make sure that the user can see the
most recent content while the application waits for input. Or maybe even
move the flush into the wait function, if so desired.
Given such an synchronous input function, parts of the user interface can be
written as stand-alone functions like this:
.. literalinclude:: sync-event-handling.c
:linenos:
:start-after: // snippet-menu-start
:end-before: // snippet-menu-end
See :download:`sync-event-handling.c` for the whole source of this example.
Callback usage
..............
Using callbacks directly needs some kind of event dispatching in the application.
There are many ways this could be done, ranging in granularity from having one
event processing function for the whole application over a function per "page"
or having a fine grained "widget" structure with elaborate event routing rules.
A simple way to do event routing is to have global variables for an event handler
and a void pointer for it's data and switch those around while the user moves
through the application. A very rough version of something like this could look
like this:
Some global variables for drawing and event handling:
.. literalinclude:: callback-event-handling.c
:linenos:
:start-after: // snippet-globals-start
:end-before: // snippet-globals-end
Instead of passing the terminal and surface object around the whole application
as parameters, having them as globals simplifies the code a lot.
The global ``current_callback`` and it's ``current_data`` allows switching which
function will get events to process while the user moves through the application.
.. literalinclude:: callback-event-handling.c
:linenos:
:start-after: // snippet-callback-start
:end-before: // snippet-callback-end
The callback passed to the terminal object just passes the event on to the
currently active event processing function.
The following is a simple confirm dialog. It can be started with a pointer to
a bool where it stores it's result. When started it replaces the currently
active event handler with it's own. When it is finished it saves the result,
restores the previous handler and calls it without an event to indicate that
the result is ready.
First the confirm dialog needs a place to store it's data:
.. literalinclude:: callback-event-handling.c
:linenos:
:start-after: // snippet-quit-data-start
:end-before: // snippet-quit-data-end
Than the start function can save the old event handler and the result pointer
and draw the initial user interface:
.. literalinclude:: callback-event-handling.c
:linenos:
:start-after: // snippet-quit-ctor-start
:end-before: // snippet-quit-ctor-end
Finally the event handling function reacts to user input and when finished
saves the result, restores the event handler and calls it:
.. literalinclude:: callback-event-handling.c
:linenos:
:start-after: // snippet-quit-callback-start
:end-before: // snippet-quit-callback-end
When using callbacks as primary means of composing the application logic,
the main function just needs to wait for events in one central place.
Thus the central loop can simply be:
.. literalinclude:: callback-event-handling.c
:linenos:
:dedent: 4
:start-after: // snippet-main-start
:end-before: // snippet-main-end
See :download:`callback-event-handling.c` for the whole source of this example.
Event loop usage
................
Existing event loops differ in their API in various details, but the general
approach is fairly similar between common event loops.
Currently the only known library to integrate termpaint into a general purpose
event loop is `Tui Widgets `_ which provides
a widget framework using the event loop from QtCore.
The general steps are:
* Setup the operating system terminal I/O interface for unbuffered input and
output processing
On \*nix like operation systems this generally means saving the current
settings via ``tcgetattr`` and configuring the needed new settings. Perhaps
using :c:func:`termpaintx_fd_set_termios`.
* Bridge input from the terminal file descriptor to termpaint
After registering an input available notifier a typical implemantation would
be::
gsize amount;
g_io_channel_read_chars(channel, buf, sizeof(buf) - 1, &amount, NULL);
termpaint_terminal_add_input_data(terminal, buf, amount);
* Pass output by termpaint to the operation system terminal interface
For best performance the output from termpaint should be buffered and send in
reasonable blocks to the terminal.
The integration will receive output date via it's ``write`` callback and needs
to flush it's output buffer when the ``flush`` callback is called.
For best performance the integration should additionally use
:c:func:`termpaint_integration_set_request_callback` to enable a mechanism for
a delayed callback used in cases where terminal input can not be readily parsed
without knowing if additional data is on it's way from the terminal to the
application.
.. rubric:: Footnotes
.. [#defcol] TERMPAINT_DEFAULT_COLOR is special as it is replaced by the
terminals with globally set colors. So using TERMPAINT_DEFAULT_COLOR as
foreground and background doesn't actually count as using the same color.
termpaint-0.3.1/doc/image.rst 0000664 0000000 0000000 00000004047 14773035472 0016120 0 ustar 00root root 0000000 0000000 Addon image
===========
The image addon contains functions to store the contents of a :c:type:`termpaint_surface` into a file or memory buffer
and to load the contents from a file or memory buffer.
This addon is only available if your compilation environment supports c++.
Functions
---------
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: _Bool termpaint_image_save(termpaint_surface *surface, const char* name)
Save the contents if the surface ``surface`` into a file with the name ``name``.
.. c:function:: bool termpaint_image_save_to_file(termpaint_surface *surface, FILE *file)
Save the contents if the surface ``surface`` into a file referred to by file pointer ``file``.
.. c:function:: char *termpaint_image_save_alloc_buffer(termpaint_surface *surface)
Save the contents if the surface ``surface`` into a freshly allocated nul-terminated buffer.
After usage the returned buffer must be deallocated using termpaint_image_save_dealloc_buffer.
.. c:function:: void termpaint_image_save_dealloc_buffer(char *buffer)
Deallocate a buffer returned by termpaint_image_save_alloc_buffer.
.. c:function:: termpaint_surface *termpaint_image_load(termpaint_terminal *term, const char *name)
Load the contents of a surface from the file named ``name`` and return a newly allocated surface with the data
from the file prepared to be used with the terminal object ``term``.
.. c:function:: termpaint_surface *termpaint_image_load_from_file(termpaint_terminal *term, FILE *file)
Load the contents of a surface from the file referred to by file pointer ``file`` and return a newly allocated surface
with the data from the file prepared to be used with the terminal object ``term``.
.. c:function:: termpaint_surface *termpaint_image_load_from_buffer(termpaint_terminal *term, char *buffer, int length)
Load the contents of a surface from a memory buffer ``buffer`` with the length ``length`` and return a newly
allocated surface with the data from the file prepared to be used with the terminal object ``term``.
termpaint-0.3.1/doc/index.rst 0000664 0000000 0000000 00000005574 14773035472 0016153 0 ustar 00root root 0000000 0000000 .. Termpaint documentation master file
Termpaint
=========
Termpaint is a low level terminal interface library for character-cell terminals
in the tradition of VT1xx (like xterm, etc).
It's designed to be portable and flexible to integrate. It covers event handling and rendering.
Features
--------
* works with and without an central event loop
* robust input handling, unknown key events are gracefully filtered out
* truecolor, soft line breaks, explicit control of trailing whitespace
* double and curly underlines, custom underline colors
* flexible support for program supplied additional formatting like hyperlinks
* block, underline and bar cursor shape
* simple grid of character cell design, support for wide characters
* does not depend on correctly set $TERM or terminfo database
* mouse event handling
* tagged paste
* mostly utf-8 based, string width routines also handle utf-16 and utf-32
* offscreen surfaces/layers
* interface with opaque structures designed for ABI stability (but breaking changes are still happening)
* possible to use where allocation failure needs to be handled gracefully
* does not use global variables where possible, can handle multiple terminals in one process
* input parsing subset usable standalone
* permissively licensed: Boost Software License 1.0
Does not contain:
* ready made user interface elements (form, menu or similar)
* window or panel abstractions
* support for non utf-8 capable terminals
Termpaint is meant as a basic building block to build more specific libraries upon. There are a lot
of different higher layer styles, so it's cleaner to have separate libraries for this.
.. TODO link more libraries when something is released in this space
Known libraries using Termpaint:
* `Tui Widgets `_ implements various common UI widgets
based on QtCore as platform abstraction.
Minimal example
---------------
A "hello world", using the internal default operating system integration and opinionated default setup.
See :doc:`getting-started` for full source.
.. literalinclude:: getting-started.c
:caption: main code
:start-after: // snippet-main-start
:end-before: // snippet-main-end
.. literalinclude:: getting-started.c
:caption: event callback
:start-after: // snippet-callback-start
:end-before: // snippet-callback-end
Support
-------
It's known to work on
* xterm
* vte
* rxvt-unicode
* mintty
* iTerm2
* microsoft terminal
* putty
* konsole
* linux
* freebsd
* and more.
The core library (but not the OS integration and the meson build system) only depend on C11 (plus a few common string
functions like strdup).
.. toctree::
:maxdepth: 2
:caption: Contents:
getting-started
terminal
integration
surface
attributes
measuring
events
details
termpaint_input
termpaintx
image
Indices and tables
==================
* :ref:`genindex`
* :ref:`search`
termpaint-0.3.1/doc/integration.rst 0000664 0000000 0000000 00000024100 14773035472 0017351 0 ustar 00root root 0000000 0000000 Integration
===========
.. c:type:: termpaint_integration
The core termpaint library does not come with integration into the operating system's input/output channels. It's designed
to be integrated into synchronous or asynchronous program designs by a pluggable integration abstraction.
There are auxiliary functions in the termpaintx_* namespace that have some common code that can be used for integrations.
But this code is fairly limited, so if more capabilities are needed feel free to copy this code into your project.
To use the simple premade integration see the :doc:`termpaintx addon`.
A user supplied integration consists of 3 major parts: terminal to termpaint communication, termpaint to terminal
communication and terminal interface setup.
Termpaint uses a semi-opaque struct which contains callbacks for calling the application provided integration code when
needed. The :c:type:`termpaint_integration` structure can be used as part of a struct in the application provided
integration code. It must be initialized by calling :c:func:`termpaint_integration_init()` with the mandatory
callbacks. Additional optional callbacks can then be set with additional functions.
When the integration is no longer needed the allocated resources have
to be freed by calling :c:func:`termpaint_integration_deinit`, possibly from the integrations ``free`` callback.
The integration is connected to a terminal object by passing a pointer to its :c:type:`termpaint_integration` struct to
:c:func:`termpaint_terminal_new` when creating the terminal object.
Input bytes from the terminal to termpaint need to be passed to :c:func:`termpaint_terminal_add_input_data`. If enough
bytes have accumulated to identify a input sequence termpaint will call the event callback set by the application using
:c:func:`termpaint_terminal_set_event_cb` with the interpreted :doc:`event `. The integration needs to take
care, that :c:func:`termpaint_terminal_add_input_data` is not called recursively from the callbacks set on the terminal.
Some platforms have kernel level terminal processing that needs to be configured for termpaint to work. On \*nix-like
platforms the kernel tty interface can be setup with :c:func:`termpaintx_fd_set_termios`. For details see the
implementation of that function. In general the terminal interface should be set to disable all kernel interpretation
and transformation features. If keyboard signal handling (ctrl-c, etc) is needed it can be left enabled. But in that
case the terminal object needs to be configured with ``+kbdsig`` to avoid switching keyboard input into advanced modes
that would be incompatible with kernel signal generation.
In addition to the kernel interface the terminal needs to be setup using configuration sequences. For this
:c:func:`termpaint_terminal_setup_fullscreen` needs to be called with the size of the terminal.
All callbacks of the integration receive a pointer to the integration struct as the first parameter. If the integration
just uses global variables the pointer can be ignored. If the integration itself uses a struct with data members the
recommended setup is to begin the custom struct with :c:type:`termpaint_integration`::
struct custom_integration {
termpaint_integration base;
// additional members go here.
}
Then the callbacks can just cast their first argument to a pointer to the custom struct.
On \*nix-like operating systems the integration should arrange for proper cleanup if the application is suddenly
terminated (e.g. a crash). The traditional way is to install signal handlers for various fatal signals and do
the cleanup before terminating the application. All functions in termpaint are unsafe for use in signal handlers, so
it's the job of the integration to save all needed information before the signal happens. There are two major parts of
state to restore. The first is the kernel terminal layer configuration, which can simply be saved before changing it to
the needed values for termpaint. The second is the state of the terminal itself that needs to be restored by outputting
a sequence of characters to the terminal. This sequence can change as different features are used, thus the integration
should set a callback via :c:func:`termpaint_integration_set_restore_sequence_updated` and save a copy of that data in
a place where the signal handler can safely access it.
An alternative without installing signal handlers is to use a auxiliary watchdog process to restore the terminal state.
The :doc:`termpaintx addon` contains functions for such an watchdog process.
See :c:func:`termpaintx_ttyrescue_start_or_nullptr` for details.
Another signal handler is needed to detect terminal size changes. \*nix-like systems raise an ``SIGWINCH`` signal if the
terminal size changes. This signal is best handled asynchronously (e.g. by using an event loop's signal support or using
a self pipe). Outside of signal context the integration can retrieve the new terminal size using the ``TIOCGWINSZ``
ioctl and resize the terminals primary surface to match using :c:func:`termpaint_surface_resize`.
Functions
---------
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: void termpaint_integration_init(termpaint_integration *integration, void (*free)(termpaint_integration *integration), void (*write)(termpaint_integration *integration, const char *data, int length), void (*flush)(termpaint_integration *integration))
This function initializes a ``termpaint_integration`` structure and sets the 3 mandatory callback functions.
All of the callbacks must be set to a non-NULL value.
The callbacks are
``void (*write)(termpaint_integration *integration, char *data, int length)``
This callback is called by termpaint to write bytes to the terminal. The application needs to implement this function
so that ``length`` bytes of data starting at ``data`` are passed to the terminal. The data should be buffered for
best performance. Termpaint will call the ``flush`` callback when the buffered data needs to be transmitted to
the terminal.
``void (*flush)(termpaint_integration *integration)``
This callback will be called when the data written using the ``write`` callback needs to be transmitted to the
terminal.
``void (*free)(termpaint_integration *integration)``
This callback is invoked when the terminal using this integration is deallocated. This function has to be provided,
but may be just a empty function if the memory of the integration is managed externally.
.. c:function:: void termpaint_integration_deinit(termpaint_integration *integration)
This function frees resources internally held by a initialized ``termpaint_integration`` structure. It must be called
exactly once for each ``termpaint_integration`` structure initialized by :c:func:`termpaint_integration_init`.
.. c:function:: void termpaint_integration_set_request_callback(termpaint_integration *integration, void (*request_callback)(termpaint_integration *integration))
Sets the optional callback ``request_callback``:
``void (*request_callback)(termpaint_integration *integration)``
With terminal input there are often cases where sequences might be finished or just the
start of a longer sequence. In this case termpaint forces to terminal to output additional data so it can make the
decision what interpretation is correct. If this callback is set it allows termpaint to delay these commands
for a short while to wait for additional bytes from the terminal.
If this callback is implemented the application needs to remember that this callback was called and after a short
delay (while processing terminal input in the usual way) call :c:func:`termpaint_terminal_callback` on the terminal.
If this callback is invoked multiple times before the application calls :c:func:`termpaint_terminal_callback` one
call is sufficient.
See also :ref:`resync`.
.. c:function:: void termpaint_integration_set_restore_sequence_updated(termpaint_integration *integration, void (*restore_sequence_updated)(termpaint_integration *integration, const char *data, int length))
Sets the optional callback ``restore_sequence_updated``:
``void (*restore_sequence_updated)(termpaint_integration *integration, const char *data, int length)``
This callback is invoked every time the sequence to reset the terminal changes. This allows to cache a current value
to be used in crash recovery or suspend signal handlers where :c:func:`termpaint_terminal_restore_sequence` can not
be used.
The restore sequence can change over time as additional terminal configuration is requested (e.g. mouse modes,
set title or global color changes).
.. c:function:: void termpaint_integration_set_is_bad(termpaint_integration *integration, _Bool (*is_bad)(termpaint_integration *integration))
Sets the optional callback ``is_bad``:
``_Bool (*is_bad)(termpaint_integration *integration)``
This callback should return false, as long as the connection to the terminal is functional.
.. c:function:: void termpaint_integration_set_awaiting_response(termpaint_integration *integration, void (*awaiting_response)(termpaint_integration *integration))
Sets the optional callback ``awaiting_response``:
``void (*awaiting_response)(termpaint_integration *integration)``
This callback is invoked when termpaint sends queries to the terminal. This can be used to decide if the integration
should wait for a little while when restoring the terminal while reading and discarding input to avoid leaving
responses to these queries in flight that might confuse the next application accessing the terminal.
.. c:function:: void termpaint_integration_set_logging_func(termpaint_integration *integration, void (*logging_func)(termpaint_integration *integration, const char *data, int length))
Sets the optional callback ``logging_func``:
``void (*logging_func)(termpaint_integration *integration, const char *data, int length)``
This callback receives logging messages. Some error messages are always
logged if this callback is specified. Additional messages can be enabled
by :c:func:`termpaint_terminal_set_log_mask`.
termpaint-0.3.1/doc/keys.rst 0000664 0000000 0000000 00000004417 14773035472 0016012 0 ustar 00root root 0000000 0000000 :orphan:
Keys
====
.. table::
:align: left
================================== =======
Function Name
================================== =======
termpaint_input_enter Enter
termpaint_input_space Space
termpaint_input_tab Tab
termpaint_input_backspace Backspace
termpaint_input_context_menu ContextMenu
termpaint_input_delete Delete
termpaint_input_end End
termpaint_input_home Home
termpaint_input_insert Insert
termpaint_input_page_down PageDown
termpaint_input_page_up PageUp
termpaint_input_arrow_down ArrowDown
termpaint_input_arrow_left ArrowLeft
termpaint_input_arrow_right ArrowRight
termpaint_input_arrow_up ArrowUp
termpaint_input_numpad_divide NumpadDivide
termpaint_input_numpad_multiply NumpadMultiply
termpaint_input_numpad_subtract NumpadSubtract
termpaint_input_numpad_add NumpadAdd
termpaint_input_numpad_enter NumpadEnter
termpaint_input_numpad_decimal NumpadDecimal
termpaint_input_numpad0 Numpad0
termpaint_input_numpad1 Numpad1
termpaint_input_numpad2 Numpad2
termpaint_input_numpad3 Numpad3
termpaint_input_numpad4 Numpad4
termpaint_input_numpad5 Numpad5
termpaint_input_numpad6 Numpad6
termpaint_input_numpad7 Numpad7
termpaint_input_numpad8 Numpad8
termpaint_input_numpad9 Numpad9
termpaint_input_escape Escape
termpaint_input_f1 F1
termpaint_input_f2 F2
termpaint_input_f3 F3
termpaint_input_f4 F4
termpaint_input_f5 F5
termpaint_input_f6 F6
termpaint_input_f7 F7
termpaint_input_f8 F8
termpaint_input_f9 F9
termpaint_input_f10 F10
termpaint_input_f11 F11
termpaint_input_f12 F12
================================== =======
termpaint-0.3.1/doc/measuring.rst 0000664 0000000 0000000 00000025610 14773035472 0017027 0 ustar 00root root 0000000 0000000 Measuring Text
===============
.. c:type:: termpaint_text_measurement
The text measurement functions are offered in variants for utf8, utf16 and utf32 to allow for flexibility in the storage
format applications use for bulk data storage. All functions should behave identical regardless of utf-variant when the
results are used according to the relevant code unit size.
Text is printed on a grid of cells. Letters like ``a`` use one cell each. But not every unicode codepoint uses one cell.
There are wide characters and characters that modify the preceding character. This text measuring api is meant to be
able to cover these special cases.
Currently it supports single cell characters, double cell characters (like Japanese characters and some emoji) and
zero width combining characters.
Logically text strings are separated into clusters. Each cluster is a unit that is displayed as one unbreakable symbol.
A cluster has a width in cells, a width in codepoints and a width in code units (bytes for utf-8, 16bit words for utf-16).
A simple example to measure the first cluster in a utf-16 string looks like this ::
termpaint_text_measurement *tm = termpaint_text_measurement_new(surface);
termpaint_text_measurement_set_limit_clusters(tm, 1);
termpaint_text_measurement_feed_utf16(tm, data, size, true);
int codePoints = termpaint_text_measurement_last_codepoints(tm);
int codeUnits = termpaint_text_measurement_last_ref(tm);
int columns = termpaint_text_measurement_last_width(tm);
termpaint_text_measurement_free(tm);
The termpaint_text_measurement_set_limit\_\* function allow to set how much of the string is measured in one call to
:c:func:`termpaint_text_measurement_feed_utf16()`. The feed function returns true if one of the set limits was reached.
When no limit is set the feed function will always return false. If more than one limit is set, the limit that is
reached first is significant.
After :c:func:`termpaint_text_measurement_feed_utf16()` returns true, the termpaint_text_measurement_last\_\* family of
functions can be used to check the measurements up to and including the last cluster that did not exceed any of the limits.
The :c:func:`termpaint_text_measurement_feed_utf16()` function is designed to allow measuring text that is stored in
multiple separate segments in memory (like in a rope or a linked list of substrings). If it returns false the application
can call it again with data from the next segment. All calls except for the call for the last segment have to be made
with the ``final`` parameter set to false.
To ensure the last cluster in a string is properly measured, the last (or only – when not using segments) call to
:c:func:`termpaint_text_measurement_feed_utf16()` has to be made with the ``final`` parameter set to true. This is
because the last cluster could still be extended by additional non spacing marks in the next segment of a string if it
would not have been the last segment.
After a limit is reached the measurement can be continued by setting a new limit and resuming with calling
:c:func:`termpaint_text_measurement_feed_utf16()` starting from the next code unit after cluster where the limit was
reached. In practice this mean starting from the ``termpaint_text_measurement_last_ref(tm)``-th code unit in the
original string. (When using segments this count includes code units from the previous segments. It is possible that
resuming a measurement needs restarting in a previous segment)
The :c:func:`termpaint_text_measurement_feed_utf8` and :c:func:`termpaint_text_measurement_feed_utf32` functions
work using the same principle, just with a different encoding for input and different code units sizes for
:c:func:`termpaint_text_measurement_last_ref`.
Mixing different variants in one measurement is possible as
long as switching between utf-variants is done only at codepoint boundaries, but should still be avoided because it makes
interpreting the results very hard.
:c:func:`termpaint_text_measurement_feed_codepoint` allows feeding in codepoints from other storage formats one by one.
It works similar, but with freely definable meaning of what exactly :c:func:`termpaint_text_measurement_last_ref` means,
as the increments for each codepoint is supplied by the user.
Functions
---------
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: termpaint_text_measurement* termpaint_text_measurement_new(termpaint_surface *surface)
Create a new text measurement object.
The application has to free this with :c:func:`termpaint_text_measurement_free()`.
The lifetime of this object must not exceed the lifetime of the terminal object
originating the passed surface.
.. c:function:: void termpaint_text_measurement_free(termpaint_text_measurement *m)
Frees the text measurement object.
.. c:function:: void termpaint_text_measurement_reset(termpaint_text_measurement *m)
Resets the text measurement object to enable use for a fresh measurement.
It removes all limits and resets the state back to zero clusters, columns, codepoints and code units.
.. c:function:: int termpaint_text_measurement_last_codepoints(termpaint_text_measurement *m)
Returns the number of code points up to and including the last measured cluster not exceeding any set limits.
.. c:function:: int termpaint_text_measurement_last_clusters(termpaint_text_measurement *m)
Returns the number of clusters up to and including the last measured cluster not exceeding any set limits.
.. c:function:: int termpaint_text_measurement_last_width(termpaint_text_measurement *m)
Returns the width in cells of the text up to and including the last measured cluster not exceeding any set limits.
.. c:function:: int termpaint_text_measurement_last_ref(termpaint_text_measurement *m)
If using :c:func:`termpaint_text_measurement_feed_utf8()`:
Returns the number of bytes up to and including the last measured cluster not exceeding any set limits.
If using :c:func:`termpaint_text_measurement_feed_utf16()`:
Returns the number of utf16 code units up to and including the last measured cluster not exceeding any set limits.
If using :c:func:`termpaint_text_measurement_feed_utf32()`:
Returns the same as :c:func:`termpaint_text_measurement_last_codepoints()`
If using :c:func:`termpaint_text_measurement_feed_codepoint()`:
Returns the sum of all ``ref_adjust`` values up to and including the last measured cluster not exceeding any set limits.
.. c:function:: int termpaint_text_measurement_pending_ref(termpaint_text_measurement *m)
Like :c:func:`termpaint_text_measurement_last_ref` but also include code units that belong the cluster currently in
processing (if any).
.. c:function:: void termpaint_text_measurement_set_limit_codepoints(termpaint_text_measurement *m, int new_value)
Sets the limit for codepoints. -1 means no limit. The limit must be greater than the current position.
.. c:function:: int termpaint_text_measurement_limit_codepoints(termpaint_text_measurement *m)
Returns the value set using :c:func:`termpaint_text_measurement_set_limit_codepoints()`.
.. c:function:: void termpaint_text_measurement_set_limit_clusters(termpaint_text_measurement *m, int new_value)
Sets the limit for clusters. -1 means no limit. The limit must be greater than the current position.
.. c:function:: int termpaint_text_measurement_limit_clusters(termpaint_text_measurement *m)
Returns the value set using :c:func:`termpaint_text_measurement_set_limit_clusters()`.
.. c:function:: void termpaint_text_measurement_set_limit_width(termpaint_text_measurement *m, int new_value)
Sets the limit for the width. -1 means no limit. The limit must be greater than the current position.
.. c:function:: int termpaint_text_measurement_limit_width(termpaint_text_measurement *m)
Returns the value set using :c:func:`termpaint_text_measurement_set_limit_width()`.
.. c:function:: void termpaint_text_measurement_set_limit_ref(termpaint_text_measurement *m, int new_value)
Sets the limit for reference. Depending on the feed function used the reference is in utf32, utf16 or utf8 code units.
-1 means no limit. The limit must be greater than the current position.
.. c:function:: int termpaint_text_measurement_limit_ref(termpaint_text_measurement *m)
Returns the value set using :c:func:`termpaint_text_measurement_set_limit_ref()`.
.. c:function:: _Bool termpaint_text_measurement_feed_utf8(termpaint_text_measurement *m, const char *code_units, int length, _Bool final)
Add the utf8 encoded string starting at ``code_units`` with length ``length`` to the measurement. Set ``final`` to
true if this is the last segment of the to be measured string.
See termpaint_text_measurement_last\_\* for functions to retrieve the measurement results.
If no limits are set, it always returns false.
Otherwise returns ``false`` if no limit was reached. Returns true if the limit was reached while measuring.
.. c:function:: _Bool termpaint_text_measurement_feed_utf16(termpaint_text_measurement *m, const uint16_t *code_units, int length, _Bool final)
Add the utf16 encoded string (in host endianness) starting at ``code_units`` with length ``length`` to the measurement.
Set ``final`` to true if this is the last segment of the to be measured string.
See termpaint_text_measurement_last\_\* for functions to retrieve the measurement results.
If no limits are set, it always returns false.
Otherwise returns ``false`` if no limit was reached. Returns true if the limit was reached while measuring.
.. c:function:: _Bool termpaint_text_measurement_feed_utf32(termpaint_text_measurement *m, const uint32_t *chars, int length, _Bool final)
Add the utf32 encoded string (in host endianness) starting at ``chars`` with length ``length`` to the measurement.
Set ``final`` to true if this is the last segment of the to be measured string.
See termpaint_text_measurement_last\_\* for functions to retrieve the measurement results.
If no limits are set, it always returns false.
Otherwise returns ``false`` if no limit was reached. Returns true if the limit was reached while measuring.
.. container:: hidden-references
.. c:macro:: TERMPAINT_MEASURE_NEW_CLUSTER
.. c:macro:: TERMPAINT_MEASURE_LIMIT_REACHED
.. c:function:: int termpaint_text_measurement_feed_codepoint(termpaint_text_measurement *m, int ch, int ref_adjust)
This is a low level function used to implement the termpaint_text_measurement_feed_utf* family of functions. It adds
a single codepoint to the measurement and returns a bit flag with the result.
if ``TERMPAINT_MEASURE_NEW_CLUSTER`` is set:
The added code point started a new cluster. The information about the previous cluster is now available using the
termpaint_text_measurement_last_* functions.
if ``TERMPAINT_MEASURE_LIMIT_REACHED`` is set:
The limit was reached while measuring. See termpaint_text_measurement_last_* for function to retrieve the
measurement results. To continue measuring the measurement needs to be restarted at the point where the limit was
reached.
termpaint-0.3.1/doc/requirements.txt 0000664 0000000 0000000 00000000077 14773035472 0017567 0 ustar 00root root 0000000 0000000 MarkupSafe <2.0
Jinja2 <3.0
sphinx >=3.3.1,<4
sphinx-autobuild
termpaint-0.3.1/doc/surface.rst 0000664 0000000 0000000 00000044107 14773035472 0016467 0 ustar 00root root 0000000 0000000 Surface
=======
.. c:type:: termpaint_surface
Surfaces are the abstraction for output into the terminal. Each :doc:`terminal object` has a primary surface
that is used for output. A pointer to the primary surface can be obtained by the :c:func:`termpaint_terminal_get_surface()`
function and output can be triggered by the :c:func:`termpaint_terminal_flush()` function. Additionally there can be
any number of offscreen surfaces for a terminal. These can be created by :c:func:`termpaint_terminal_new_surface()`.
The offscreen surfaces can by copied to other surfaces using the :c:func:`termpaint_surface_copy_rect()` function to
ultimately either copy to the primary surface or to save the contents to external storage.
Output to a surface is done using the :c:func:`termpaint_surface_write_*` family of
functions for output of text or symbols and the
:c:func:`termpaint_surface_clear_rect*` family of functions for clearing areas
of the surface.
The surface is a rectangle of cells. The cells each have the same size. The smallest unit of text that can be rendered
is a cluster that represents a "character" and covers one cell or two cells next to each other on a line. Each cluster
additionally has a foreground color, a background color, a decoration color and a combination of styles.
.. note:: In many terminal the foreground color and some attributes are even important for blank cells. For example
text selection might not display properly if foreground and background color are the same. For best compatibility
always use a combination of foreground and background color that has decent contrast.
Blank space at the end of a line is handled specially in many terminals. For example, for the terminal native text
selection, a range of cells at the end of the line can be ignored for text selection's contents if they are detected as
insignificant. Termpaint allows marking cells as erased to mirror this behavior. All cells at the very end of a line
that are marked as erased are send to the terminals as insignificant, if supported by the terminal.
.. container:: hidden-references
.. c:macro:: TERMPAINT_ERASED
When using one of the clear functions or writing ``TERMPAINT_ERASED`` characters in a surface these cells will be
counted as erased and not be considered significant spaces at the end of a line in supported terminals.
Terminals commonly group lines into paragraphs to determine if text that is copied with the terminal native
clipboard support should contain line breaks between lines of the terminal display. For compatible terminals
termpaint can connect subsequent lines into a paragraph using soft wrap markers. If a line ends in a cell with
a soft wrap marker and the following line begins with a cell with a soft wrap marker termpaint will connect both lines
into a paragraph. Applications can set those using :c:func:`termpaint_surface_set_softwrap_marker` after writing
text to the cell.
Many surface function take an pointer to an :doc:`attribute object` to specify the colors and styles to be
used for the modified cells.
Furthermore there are functions to read back the current contents of a surface (see the
:c:func:`termpaint_surface_peek_*` family of functions) and to compare the contents of
two surfaces (:c:func:`termpaint_surface_same_contents()`) as well are changing the color of the cells on
a surface (:c:func:`termpaint_surface_tint()`).
Functions
---------
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: termpaint_surface *termpaint_terminal_new_surface(termpaint_terminal *term, int width, int height)
Creates an new off-screen surface for usage with terminal object ``term``. The new surface has the size ``width``
columns by ``height`` lines and is initialized with spaces with default attributes (TERMPAINT_DEFAULT_COLOR for all
colors).
The application has to free this with :c:func:`termpaint_surface_free`.
The lifetime of this object must not exceed the lifetime of the passed terminal object.
.. c:function:: termpaint_surface *termpaint_surface_new_surface(termpaint_surface *surface, int width, int height)
Like :c:func:`termpaint_terminal_new_surface` but instead of directly requiring a terminal object uses a existing
surface for that terminal object.
The lifetime of this object must not exceed the lifetime of the terminal object originating the passed surface.
.. c:function:: termpaint_surface *termpaint_surface_duplicate(termpaint_surface *surface)
Creates an new off-screen surface for usage with terminal object for which the source surface ``surface``
was created. The new surface has the same size as the source surface ``surface`` and is initialized with
a copy of the source surface ``surface`` content.
The application has to free this with :c:func:`termpaint_surface_free`.
.. c:function:: void termpaint_surface_free(termpaint_surface *surface)
Frees a surface allocated with :c:func:`termpaint_terminal_new_surface`. This must not be called on the primary
surface of a terminal object, because that is owned by the terminal object.
.. c:function:: void termpaint_surface_resize(termpaint_surface *surface, int width, int height)
Change the size of a surface to ``width`` columns by ``height`` lines. The current contents is erased as if the
surface had been freshly created by :c:func:`termpaint_terminal_new_surface`.
.. c:function:: int termpaint_surface_width(const termpaint_surface *surface)
Returns the current width of the surface.
.. c:function:: int termpaint_surface_height(const termpaint_surface *surface)
Returns the current height of the surface.
.. c:function:: void termpaint_surface_write_with_attr(termpaint_surface *surface, int x, int y, const char *string, const termpaint_attr *attr)
Write a text given in the null terminated utf8 string ``string`` to the surface starting in cell ``x``, ``y``.
Uses ``attr`` as attributes for all newly placed characters.
The length of the run of cells where the characters will be placed can be calculated using the
:doc:`string measurement functions`.
If any modified cells have previously been part of a multicell character cluster the cluster as a whole is erased.
Cells not overwritten will keep their previous attributes (colors, etc).
If ``string`` contains the special character :c:macro:`TERMPAINT_ERASED` the corresponding cells are marked as erased.
.. c:function:: void termpaint_surface_write_with_len_attr(termpaint_surface *surface, int x, int y, const char *string, int len, const termpaint_attr *attr)
Like :c:func:`termpaint_surface_write_with_attr()` but does take a explicit length parameter instead of
writing the string until it encounters a NUL character in the string.
.. c:function:: void termpaint_surface_write_with_attr_clipped(termpaint_surface *surface, int x, int y, const char *string, const termpaint_attr *attr, int clip_x0, int clip_x1)
Like :c:func:`termpaint_surface_write_with_attr()` but additionally applies clipping so that only cells in column
``clip_x0`` (inclusive) to column ``clip_x1`` are used for placing characters. ``x`` may be less than ``clip_x0``,
in that case characters at the start of the string are not placed as needed to maintain the clipping interval.
The clip range does *not* prevent modifications of characters outside of the interval to be changed if a existing
cluster in surface cross the clipping boundary. In that case if that cluster is partially overwritten the part
outside the interval is erased (preserving its previous attributes).
.. c:function:: void termpaint_surface_write_with_len_attr_clipped(termpaint_surface *surface, int x, int y, const char *string, int len, const termpaint_attr *attr, int clip_x0, int clip_x1)
Like :c:func:`termpaint_surface_write_with_attr_clipped()` but does take a explicit length parameter instead of
writing the string until it encounters a NUL character in the string.
.. c:function:: void termpaint_surface_write_with_colors(termpaint_surface *surface, int x, int y, const char *string, int fg, int bg)
Like :c:func:`termpaint_surface_write_with_attr()` but with explicit parameters for foreground and background color.
Decoration color will be set to TERMPAINT_DEFAULT_COLOR and no style attributes will be applied.
See :ref:`colors` for how to specify colors.
.. c:function:: void termpaint_surface_write_with_len_colors(termpaint_surface *surface, int x, int y, const char *string, int len, int fg, int bg)
Like :c:func:`termpaint_surface_write_with_colors()` but does take a explicit length parameter instead of
writing the string until it encounters a NUL character in the string.
.. c:function:: void termpaint_surface_write_with_colors_clipped(termpaint_surface *surface, int x, int y, const char *string, int fg, int bg, int clip_x0, int clip_x1)
Like :c:func:`termpaint_surface_write_with_attr_clipped()` but with explicit parameters for foreground and background color.
Decoration color will be set to TERMPAINT_DEFAULT_COLOR and no style attributes will be applied.
See :ref:`colors` for how to specify colors.
.. c:function:: void termpaint_surface_write_with_len_colors_clipped(termpaint_surface *surface, int x, int y, const char *string, int fg, int bg, int clip_x0, int clip_x1)
Like :c:func:`termpaint_surface_write_with_colors_clipped()` but does take a explicit length parameter instead of
writing the string until it encounters a NUL character in the string.
.. c:function:: void termpaint_surface_clear(termpaint_surface *surface, int fg, int bg)
Clear the contents of the whole surface. All cells are set to spaces with ``fg`` as foreground color and ``bg`` as
background color. Decoration color will be set to TERMPAINT_DEFAULT_COLOR and no style attributes will be applied.
The cleared cell will be marked as erased.
See :ref:`colors` for how to specify colors.
.. c:function:: void termpaint_surface_clear_with_attr(termpaint_surface *surface, const termpaint_attr *attr)
Clear the contents of the whole surface. All cells are set to spaces with attributes set to the contents of ``attr``.
The cleared cell will be marked as erased.
.. c:function:: void termpaint_surface_clear_rect(termpaint_surface *surface, int x, int y, int width, int height, int fg, int bg)
Like :c:func:`termpaint_surface_clear()` but only clears the rectangle starting from cell at ``x``, ``y`` in it's upper
left corner with with width ``width`` and height ``height``.
If clusters cross the boundary of the rectangle, these clusters are completely erased. Portions of these clusters
outside of the rectangle preserve their colors and attributes.
The cleared cell will be marked as erased.
See :ref:`colors` for how to specify colors.
.. c:function:: void termpaint_surface_clear_rect_with_attr(termpaint_surface *surface, int x, int y, int width, int height, const termpaint_attr *attr)
Like :c:func:`termpaint_surface_clear_with_attr()` but only clears the rectangle starting from cell at ``x``, ``y``
in it's upper left corner with with width ``width`` and height ``height``.
If clusters cross the boundary of the rectangle, these clusters are completely erased. Portions of these clusters
outside of the rectangle preserve their colors and attributes.
The cleared cell will be marked as erased.
.. c:function:: void termpaint_surface_clear_with_char(termpaint_surface *surface, int fg, int bg, int codepoint)
Like :c:func:`termpaint_surface_clear` but the cells will be filled with the character ``codepoint`` and marked as not erased.
.. c:function:: void termpaint_surface_clear_with_attr_char(termpaint_surface *surface, const termpaint_attr *attr, int codepoint)
Like :c:func:`termpaint_surface_clear_with_attr` but the cells will be filled with the character ``codepoint`` and marked as not erased.
.. c:function:: void termpaint_surface_clear_rect_with_char(termpaint_surface *surface, int x, int y, int width, int height, int fg, int bg, int codepoint)
Like :c:func:`termpaint_surface_clear_rect` but the cells will be filled with the character ``codepoint`` and marked as not erased.
.. c:function:: void termpaint_surface_clear_rect_with_attr_char(termpaint_surface *surface, int x, int y, int width, int height, const termpaint_attr *attr, int codepoint)
Like :c:func:`termpaint_surface_clear_rect_with_attr` but the cells will be filled with the character ``codepoint`` and marked as not erased.
.. c:function:: void termpaint_surface_set_fg_color(const termpaint_surface *surface, int x, int y, unsigned fg)
Replaces the foreground color of the cluster at position ``x``, ``y`` with the color given in ``fg``.
.. c:function:: void termpaint_surface_set_bg_color(const termpaint_surface *surface, int x, int y, unsigned bg)
Replaces the background color of the cluster at position ``x``, ``y`` with the color given in ``bg``.
.. c:function:: void termpaint_surface_set_deco_color(const termpaint_surface *surface, int x, int y, unsigned deco_color)
Replaces the decoration color of the cluster at position ``x``, ``y`` with the color given in ``deco_color``.
.. c:function:: void termpaint_surface_set_softwrap_marker(termpaint_surface *surface, int x, int y, _Bool state)
This function sets or remove a soft wrap marker in a given cell. If ``state`` is true, the marker is set, otherwise
it is removed. The marker will also be removed by writing new text to the cell or using a clear function.
See above for how soft wrap markers are used to connect lines into paragraphs for native terminal
clipboard functionality.
.. c:function:: void termpaint_surface_copy_rect(termpaint_surface *src_surface, int x, int y, int width, int height, termpaint_surface *dst_surface, int dst_x, int dst_y, int tile_left, int tile_right)
Copies the contents of the rectangle with the upper-left corner ``x``, ``y`` and width ``width`` and height ``height``
in surface ``src_surface`` into the surface ``dst_surface`` at position ``dst_x``, ``dst_y``.
Overlapping source and destination rectangles are supported.
If clusters in the source or destination surface cross the boundary of the rectangle the behavior depends on the
values in ``tile_left`` for the left boundary and ``tile_right`` for the right boundary.
The following tiling modes are available:
.. c:namespace:: 0
.. c:macro:: TERMPAINT_COPY_NO_TILE
Partial clusters in the source are copied to the destination as spaces for the parts of the cluster that is inside
the rectangle. If clusters in the destination cross the boundary they are erased before the copy is made. (The
part of the cluster outside the rectangle preserves it's attributes but the text is replaced by spaces)
.. c:macro:: TERMPAINT_COPY_TILE_PUT
Clusters in the source will be copied into the destination even if that means modifying cells outside of the
destination rectangle. This allows copying a larger region in multiple steps.
.. c:macro:: TERMPAINT_COPY_TILE_PRESERVE
If clusters in the destination line up with clusters in source, the cluster in the destination is preserved. This
allows seamlessly extending a copy made with ``TERMPAINT_COPY_TILE_PUT`` without overwriting previously copied
cells.
.. c:function:: void termpaint_surface_tint(termpaint_surface *surface, void (*recolor)(void *user_data, unsigned *fg, unsigned *bg, unsigned *deco), void *user_data)
Changes the colors of all cells of the surface according to the recoloration function ``recolor``.
This function is called for each cluster with the ``user_data`` and a pointer to locations that hold the foreground,
background and decoration colors of that cluster. The function can then recolor that cluster by changing the values
pointed to.
.. c:function:: unsigned termpaint_surface_peek_fg_color(const termpaint_surface *surface, int x, int y)
Return the foreground color of the cluster at ``x``, ``y``.
.. c:function:: unsigned termpaint_surface_peek_bg_color(const termpaint_surface *surface, int x, int y)
Return the background color of the cluster at ``x``, ``y``.
.. c:function:: unsigned termpaint_surface_peek_deco_color(const termpaint_surface *surface, int x, int y)
Return the decoration color of the cluster at ``x``, ``y``.
.. c:function:: int termpaint_surface_peek_style(const termpaint_surface *surface, int x, int y)
Return the style of the cluster at ``x``, ``y``.
.. c:function:: void termpaint_surface_peek_patch(const termpaint_surface *surface, int x, int y, const char **setup, const char **cleanup, _Bool *optimize)
Place the low level patching information of the cluster at ``x``, ``y`` into to locations pointed to by ``setup``,
``cleanup`` and ``optimize``. The strings are owned by the surface and must not be freed.
.. c:function:: const char *termpaint_surface_peek_text(const termpaint_surface *surface, int x, int y, int *len, int *left, int *right)
Return the text of the cluster at ``x``, ``y``. The returned string is not null terminated. It's length is stored into
the location pointed to by ``len``. If non-zero the locations pointed to by ``left`` and ``right`` receive the
columns of the left most and right most cell that is part of the cluster.
If a cell is cleared this function returns a pointer to the special character :c:macro:`TERMPAINT_ERASED`.
.. c:function:: _Bool termpaint_surface_peek_softwrap_marker(const termpaint_surface *surface, int x, int y)
This function returns true if a soft wrap marker is set in a given cell.
.. c:function:: _Bool termpaint_surface_same_contents(const termpaint_surface *surface1, const termpaint_surface *surface2)
Compares two surfaces. If both have the same contents and attributes for every cell/cluster then it returns true.
.. c:function:: int termpaint_surface_char_width(const termpaint_surface *surface, int codepoint)
Returns the "width" of a character with Unicode codepoint ``codepoint``.
Prefer the :doc:`string measurement functions` to using this function directly.
Return values are
0
This character combines with previous characters into a cluster
1
This character takes one cell of space.
2
This character takes two cells of space.
termpaint-0.3.1/doc/sync-event-handling.c 0000664 0000000 0000000 00000010555 14773035472 0020326 0 ustar 00root root 0000000 0000000 // Feel free to copy from this example to your own code
// SPDX-License-Identifier: 0BSD OR BSL-1.0 OR MIT-0
#include
#include
#include
#include "termpaint.h"
#include "termpaintx.h"
// snippet-type-start
typedef struct event_ {
int type;
int modifier;
char *string;
struct event_* next;
} event;
event* event_current; // unprocessed event
event* event_saved; // event to free on next call
// snippet-type-end
// snippet-callback-start
void event_callback(void *userdata, termpaint_event *tp_event) {
(void)userdata;
// remember tp_event is only valid while this callback runs, so copy everything we need.
event *copied_event = NULL;
if (tp_event->type == TERMPAINT_EV_CHAR) {
copied_event = malloc(sizeof(event));
copied_event->type = tp_event->type;
copied_event->modifier = tp_event->c.modifier;
copied_event->string = strndup(tp_event->c.string, tp_event->c.length);
copied_event->next = NULL;
} else if (tp_event->type == TERMPAINT_EV_KEY) {
copied_event = malloc(sizeof(event));
copied_event->type = tp_event->type;
copied_event->modifier = tp_event->key.modifier;
copied_event->string = strndup(tp_event->key.atom, tp_event->key.length);
copied_event->next = NULL;
}
if (copied_event) {
if (!event_current) {
event_current = copied_event;
} else {
event* prev = event_current;
while (prev->next) {
prev = prev->next;
}
prev->next = copied_event;
}
}
}
// snippet-callback-end
// snippet-wait-start
event* key_wait(termpaint_integration *integration) {
while (!event_current) {
if (!termpaintx_full_integration_do_iteration(integration)) {
// some kind of error
return NULL; // or some other error handling
}
}
if (event_saved) {
free(event_saved->string);
free(event_saved);
}
event *ret = event_current;
event_current = ret->next;
event_saved = ret;
return ret;
}
// snippet-wait-end
// snippet-menu-start
bool quit_menu(termpaint_terminal *terminal, termpaint_integration *integration) {
termpaint_surface *surface;
surface = termpaint_terminal_get_surface(terminal);
int fg = TERMPAINT_DEFAULT_COLOR;
int bg = TERMPAINT_DEFAULT_COLOR;
termpaint_surface_write_with_colors(surface, 20, 4, "Really quit? (y/N)",
fg, bg);
termpaint_terminal_flush(terminal, false);
while (true) {
event *event = key_wait(integration);
if (event->type == TERMPAINT_EV_CHAR) {
if (!strcmp(event->string, "y") || !strcmp(event->string, "Y")) {
return true;
}
if (!strcmp(event->string, "n") || !strcmp(event->string, "N")) {
return false;
}
}
termpaint_surface_write_with_colors(surface, 20, 5,
"Please reply with either 'y' for yes or 'n' for no.",
fg, bg);
termpaint_terminal_flush(terminal, false);
}
}
// snippet-menu-end
int main(int argc, char **argv) {
(void)argc; (void)argv;
termpaint_integration *integration;
termpaint_terminal *terminal;
termpaint_surface *surface;
integration = termpaintx_full_integration_setup_terminal_fullscreen(
"+kbdsig +kbdsigint",
event_callback, NULL,
&terminal);
surface = termpaint_terminal_get_surface(terminal);
termpaint_surface_clear(surface,
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
termpaint_surface_write_with_colors(surface,
0, 0,
"Hello World",
TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
// snippet-main-start
termpaint_terminal_flush(terminal, false);
while (true) {
event *event = key_wait(integration);
if (event->type == TERMPAINT_EV_CHAR) {
if (strcmp(event->string, "q") == 0) {
break;
}
}
if (event->type == TERMPAINT_EV_KEY) {
if (strcmp(event->string, "Escape") == 0) {
break;
}
}
}
// snippet-main-end
quit_menu(terminal, integration);
termpaint_terminal_free_with_restore(terminal);
return 0;
}
termpaint-0.3.1/doc/terminal.rst 0000664 0000000 0000000 00000074235 14773035472 0016657 0 ustar 00root root 0000000 0000000 Terminal
========
.. c:type:: termpaint_terminal
The terminal object represents a connected terminal. This can be seen as the root object in termpaint.
The actual connection with the terminal is left to the application. It can be connected to both a operating system
terminal as well as to network protocols with suitable glue.
The terminal always needs an bi-directional connection for the terminal object to work.
See :doc:`integration` for how write a custom integrate of termpaint into an application.
See :doc:`termpaintx` for a simple premade integration suitable for simple applications using a synchronous
usage style or which work with a very simple event loop design.
Terminals have different capabilities and thus a auto detection step is recommended before using the terminal
in the application.
Input and other events from the terminal are passed to the application using callback functions.
The primary callback is the event callback which is called for keyboard input, mouse events and clipboard
paste events. Use :c:func:`termpaint_terminal_set_event_cb()` to setup your event callback. This callback
is required.
Output is done by placing text on the primary surface of the terminal. This surface can be obtained by
:c:func:`termpaint_terminal_get_surface()`. After all text is in place, call :c:func:`termpaint_terminal_flush()`
to output the contents of the surface to the terminal. If no full repaint is requested this will only send
:ref:`differences` since the last flush to the terminal.
.. _terminal-setup:
Setup
-----
The terminal object works better with terminal specific setup which can enabled by doing a terminal auto-detection before
calling :c:func:`termpaint_terminal_setup_fullscreen`. The terminal auto-detection can be started using
:c:func:`termpaint_terminal_auto_detect`. This will initiate bidirectional communication to the terminal. The application
can proceed with the setup when the detection is finished.
For applications preferring synchronous integration the application should call
:c:func:`termpaint_terminal_auto_detect_state` after each additional input from the terminal. If this function returns
``termpaint_auto_detect_done`` the detection is finished.
For applications preferring asynchronous integration the application needs to wait for an event of type
:c:macro:`TERMPAINT_EV_AUTO_DETECT_FINISHED` before proceeding with terminal setup.
In either case the application needs to set an event callback before starting auto-detection.
Applications should call either :c:func:`termpaint_terminal_setup_fullscreen`
or :c:func:`termpaint_terminal_setup_inline` after
terminal detection to setup the terminal for the chosen mode.
In fullscreen mode the application claims and repaints the full terminal screen.
If the terminal supports alternative screen mode, the terminal contents is not erased by the application and reappears
after the application quits.
In inline mode the application instead claims a stripe with limited height for display.
This stripe starts at the line where the cursor is located.
If the requested number of lines in not available the terminal will be scrolled to make the necessary space available.
(Requesting a stripe higher than the terminal height is invalid and will lead to display corruption)
When the application terminates in inline mode the cursor is reset to the top line of
the stripe and the output stripe is erased.
For clean shutdown the application needs to restore both terminal configuration as well as the kernel level terminal
setup back to it's previous values. The first part should be done by calling
:c:func:`termpaint_terminal_free_with_restore`. The second part should be done by using operating system specific calls
to save the kernel settings before changing those and then restoring them after restoring the terminal setup.
Common functions
----------------
These functions are commonly used when a initialized terminal object has been acquired.
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: void termpaint_terminal_free_with_restore(termpaint_terminal *term)
Frees the terminal object ``term`` and restores the attached terminal to its base state.
This function calls the integrations free callback.
.. c:function:: void termpaint_terminal_free_with_restore_and_persistent(termpaint_terminal *term, termpaint_surface *surface)
Frees the terminal object ``term`` and restores the attached terminal to its base state.
The contents of the surface ``surface`` is left visible on the terminal.
The cursor is placed after the contents of ``surface``.
If ``surface`` is NULL, this function is the same as :c:func:`termpaint_terminal_free_with_restore()`.
This function calls the integrations free callback.
.. c:function:: void termpaint_terminal_free(termpaint_terminal *term)
Frees the terminal object ``term`` without restoring the attached terminal to it's base state. This will leave the
terminal in a state that other applications or the shell will not be prepared to handle in most cases.
Prefer to use :c:func:`termpaint_terminal_free_with_restore()`.
This function calls the integrations free callback.
.. c:function:: void termpaint_terminal_set_event_cb(termpaint_terminal *term, void (*cb)(void *user_data, termpaint_event* event), void *user_data)
The application must use this function to set an event callback. See :doc:`events` for details about events produced
by terminal input.
This is mostly a wrapper for using :c:func:`termpaint_input_set_event_cb` with a terminal object. Termpaint interprets
certain events before passing them on to the application. Also, while running terminal auto detection, events are not
passed to the given callback. Some events like :c:macro:`TERMPAINT_EV_AUTO_DETECT_FINISHED` are actually produced by
termpaint and not by termpaint_input.
.. c:function:: termpaint_surface *termpaint_terminal_get_surface(termpaint_terminal *term)
Returns the primary surface of the terminal object ``term``. This surface is linked to the terminal and can be
output using :c:func:`termpaint_terminal_flush`.
This object is owned by the terminal object, don't free the returned value.
.. c:function:: void termpaint_terminal_flush(termpaint_terminal *term, bool full_repaint)
Output the current state of the primary surface of the terminal object to the attached terminal.
If ``full_repaint`` is false it uses :ref:`incremental drawing` to reduce bandwidth use.
Else it does a full redraw that can repair the contents of the terminal in case another application
interfered with uncoordinated output to the same underlying terminal.
.. c:function:: void termpaint_terminal_set_cursor_position(termpaint_terminal *term, int x, int y)
Sets the text cursor position for the terminal object ``term``. The cursor is moved to this position
the next time :c:func:`termpaint_terminal_flush` is called.
.. c:function:: void termpaint_terminal_set_cursor_visible(termpaint_terminal *term, bool visible)
Sets the visibility of the text cursor for the terminal object ``term``. The cursor is shown/hidden
the next time :c:func:`termpaint_terminal_flush` is called.
.. c:function:: void termpaint_terminal_set_cursor_style(termpaint_terminal *term, int style, bool blink)
Sets the cursor shape / style of the terminal object ``term`` to the style specified in ``style``.
If ``blink`` is true, the cursor will blink.
The following styles are available:
.. c:namespace:: 0
.. c:macro:: TERMPAINT_CURSOR_STYLE_TERM_DEFAULT
This is the terminal default style. This is terminal implementation and configuration defined.
.. c:macro:: TERMPAINT_CURSOR_STYLE_BLOCK
Display the cursor as a block that covers an entire character.
.. c:macro:: TERMPAINT_CURSOR_STYLE_UNDERLINE
Display the cursor as a underline under the character.
.. c:macro:: TERMPAINT_CURSOR_STYLE_BAR
Display the cursor as a vertical bar between characters.
.. c:function:: void termpaint_terminal_set_title(termpaint_terminal *term, const char* title, int mode)
Set the title of the terminal to the string ``title``. ``mode`` specifies how to handle terminals where
it is not certain that the original title can be restored when exiting the application.
.. c:namespace:: 0
.. c:macro:: TERMPAINT_TITLE_MODE_ENSURE_RESTORE
Only set the title if it is certain that the original title can be restored when the application restores
the terminal.
This is the recommended mode.
.. c:macro:: TERMPAINT_TITLE_MODE_PREFER_RESTORE
Set the title on all terminals that support setting a title without restricting to terminals that are known
to be able to restore the title when the application restores the terminal.
.. c:function:: void termpaint_terminal_set_icon_title(termpaint_terminal *term, const char* title, int mode)
This function is like :c:func:`termpaint_terminal_set_title` but does not set the primary title but an alternative
title called the icon title. Interpretation of this title differs by terminal.
.. c:function:: void termpaint_terminal_set_color(termpaint_terminal *term, int color_slot, int r, int b, int g)
Set special global (not per cell) terminal colors.
``color_slot`` can be one of:
.. c:namespace:: 0
.. c:macro:: TERMPAINT_COLOR_SLOT_BACKGROUND
This is the color used for cells without an explicitly set background. This color is used e.g. for cells
using the :c:macro:`TERMPAINT_DEFAULT_COLOR` as background.
.. c:macro:: TERMPAINT_COLOR_SLOT_FOREGRUND
This is the color used for cells without an explicitly set foreground. This color is used e.g. for cells
using the :c:macro:`TERMPAINT_DEFAULT_COLOR` as foreground.
.. c:macro:: TERMPAINT_COLOR_SLOT_CURSOR
Set the color of the cursor in the terminal.
.. c:function:: void termpaint_terminal_reset_color(termpaint_terminal *term, int color_slot)
Reset color choices made using :c:func:`termpaint_terminal_set_color`. When ``color_slot`` is
``TERMPAINT_COLOR_SLOT_CURSOR`` the cursor color is reset to the default.
.. c:function:: void termpaint_terminal_set_inline(termpaint_terminal *terminal, _Bool enabled)
Switch between inline and fullscreen mode.
If ``enabled`` is true switch to inline mode.
Otherwise switch to fullscreen mode.
A call to this function must be followed by reestablishing the primary surface size and contents and
by a call to :c:func:`termpaint_terminal_flush()` to finalize the switch to the new mode.
Note: As primary surface resizing requirements differ between inline and fullscreen mode, check if your
integration has an API for switching that needs to be called in addition or instead of this function.
For example when using termpaintx :c:func:`termpaintx_full_integration_set_inline` needs to be called instead of
this function.
.. c:function:: void termpaint_terminal_request_tagged_paste(termpaint_terminal *term, _Bool enabled)
Request the terminal to send the needed information so :c:macro:`TERMPAINT_EV_PASTE` events can be generated.
.. c:function:: void termpaint_terminal_set_mouse_mode(termpaint_terminal *term, int mouse_mode)
Request the terminal to enable mouse handling by the application. Depending on the setting
:c:macro:`TERMPAINT_EV_MOUSE` events will be generated for:
.. c:namespace:: 0
.. c:macro:: TERMPAINT_MOUSE_MODE_OFF
No events.
Terminal native select and copy features will be available to the user.
.. c:macro:: TERMPAINT_MOUSE_MODE_CLICKS
Only report mouse down and up events (clicks).
Terminal native select and copy features will not be available to the user. Some terminals allow
overriding this mouse mode using shift temporarily.
.. c:macro:: TERMPAINT_MOUSE_MODE_DRAG
Report mouse down and up events as well as movement when at least one mouse button is held down.
Terminal native select and copy features will not be available to the user. Some terminals allow
overriding this mouse mode using shift temporarily.
.. c:macro:: TERMPAINT_MOUSE_MODE_MOVEMENT
Report mouse movement and down and up events independent of mouse button state.
Terminal native select and copy features will not be available to the user. Some terminals allow
overriding this mouse mode using shift temporarily.
.. c:function:: void termpaint_terminal_request_focus_change_reports(termpaint_terminal *term, _Bool enabled)
Request focus change events from the terminal. If supported by the terminal these events will be reported
as :ref:`misc-events` of type :c:func:`termpaint_input_focus_in` and :c:func:`termpaint_input_focus_out`.
.. c:function:: _Bool termpaint_terminal_should_use_truecolor(termpaint_terminal *terminal)
After auto detection, returns true if termpaint does not translate rgb color colors to indexed colors.
To force passing rgb colors to the terminal, one of the the capabilities
:c:macro:`TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED`
or :c:macro:`TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED` must be set.
.. c:function:: void termpaint_terminal_bell(termpaint_terminal *term)
Send the BEL character to the terminal. Most terminals trigger a visual or audio reaction to the BEL character.
Functions for setup and auto-detection
--------------------------------------
These functions are used to get a initialized terminal object and are somewhat dependent on the integration used.
For the integration from the :doc:`termpaintx addon` a convenience function encapsulating the setup is
available as :c:func:`termpaintx_full_integration_setup_terminal_fullscreen` that can be used instead.
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: termpaint_terminal *termpaint_terminal_new(termpaint_integration *integration)
Create a new terminal object.
See :doc:`integration` for details on the callbacks needed in ``integration``.
The application has to free this with :c:func:`termpaint_terminal_free_with_restore()` or
:c:func:`termpaint_terminal_free()`
If the integration's free callback frees the integration this takes ownership of the integration.
.. c:function:: bool termpaint_terminal_auto_detect(termpaint_terminal *terminal)
Starts terminal type auto-detection. The event callback has to be set before calling this function.
Return false, if the auto-detection could not be started.
.. c:enum:: termpaint_auto_detect_state_enum
.. c:namespace:: 0
.. c:enumerator:: termpaint_auto_detect_none
Terminal type auto-detection was not run yet.
.. c:enumerator:: termpaint_auto_detect_running
Terminal type auto-detection is currently running.
.. c:enumerator:: termpaint_auto_detect_done
Terminal type auto-detection was run and has finished.
.. c:function:: enum termpaint_auto_detect_state_enum termpaint_terminal_auto_detect_state(const termpaint_terminal *terminal)
Get the state of a possibly running terminal type auto-detection.
.. c:function:: _Bool termpaint_terminal_might_be_supported(const termpaint_terminal *terminal)
After auto detection, returns true if the terminal might be supported. If it returns false the terminal
is likely missing essential features for proper support.
.. _termpaint-fullscreen-options:
.. c:function:: void termpaint_terminal_setup_fullscreen(termpaint_terminal *terminal, int width, int height, const char *options)
Setup the terminal connected to the terminal object ``term`` to fullscreen mode. Assume terminal size is ``width``
columns by ``height`` lines.
``options`` specifies an space delimited list of additional settings:
``-altscreen``
Do not activate the alternative screen of the terminal. Previous contents of the screen is not restored after
terminating the application.
``+kbdsig``
Do not activate any modes of the terminal that might conflict with processing of keyboard signals in the kernel
tty layer. Use this when passing ``+kdbsigint``, ``+kdbsigquit`` or ``+kdbsigtstp`` to
:c:func:`termpaintx_full_integration` or when using an custom integration that enabled the equivalent kernel
terminal layer processing.
Affected key combinations are usually ctrl-c, ctrl-z and, ctrl-\\
.. _termpaint-inline-options:
.. c:function:: void termpaint_terminal_setup_inline(termpaint_terminal *terminal, int width, int height, const char *options)
Setup the terminal connected to the terminal object ``term`` to inline mode. Assume terminal size is ``width``
columns. And the initially used height is ``height`` lines.
``options`` specifies an space delimited list of additional settings:
``+kbdsig``
Do not activate any modes of the terminal that might conflict with processing of keyboard signals in the kernel
tty layer. Use this when passing ``+kdbsigint``, ``+kdbsigquit`` or ``+kdbsigtstp`` to
:c:func:`termpaintx_full_integration` or when using an custom integration that enabled the equivalent kernel
terminal layer processing.
Affected key combinations are usually ctrl-c, ctrl-z and, ctrl-\\
In inline mode termpaint does not paint the full screen, but it only paints a vertical stripe starting at the
previous cursor position of a given height.
This allows integration of the output into the "transcript" of commands in a command line environment.
For example implementing entering of interactive commands.
Inline mode never uses the alternative screen of the terminal itself.
But when switching from inline mode to fullscreen mode, alternative screen mode is always used when available.
.. c:function:: void termpaint_terminal_auto_detect_apply_input_quirks(termpaint_terminal *terminal, _Bool backspace_is_x08)
Setup input handling based on the auto detection result and ``backspace_is_x08``.
Needs to be called after auto detection is finished.
Pass ``backspace_is_x08`` as true if the terminal uses 0x08 (ASCII BS) for the backspace key.
On \*nix platforms this information can be obtained from the ``termios`` structure by ``original_termios.c_cc[VERASE] == 0x08``.
For ssh connections the VERASE value is transmitted as part of the pseudo terminal request in the encoded
terminal modes.
Special purpose functions
-------------------------
These functions have specialized use. They are not needed in many applications.
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: void termpaint_terminal_pause(termpaint_terminal *term)
Temporarily restore the terminal state. This should be called before running external applications.
To return to rendering by termpaint call :c:func:`termpaint_terminal_unpause`.
After calling this function the application still needs to restore the kernel tty layer settings
to the state needed to run external applications.
.. c:function:: void termpaint_terminal_pause_and_persistent(termpaint_terminal *term, termpaint_surface *surface)
Temporarily restore the terminal state. This should be called before running external applications.
The contents of the surface ``surface`` is left visible on the terminal.
The cursor is placed after the contents of ``surface``.
If ``surface`` is NULL, this function is the same as :c:func:`termpaint_terminal_pause_and_persistent()`.
To return to rendering by termpaint call :c:func:`termpaint_terminal_unpause`.
After calling this function the application still needs to restore the kernel tty layer settings
to the state needed to run external applications.
.. c:function:: void termpaint_terminal_unpause(termpaint_terminal *term)
This function activates termpaint mode again after it was previously temporarily restored to the
normal state.
Before calling this function the application needs to restore the kernel tty layer settings to
the state needed by termpaint (or to the state before calling pause).
.. c:function:: void termpaint_terminal_set_raw_input_filter_cb(termpaint_terminal *term, bool (*cb)(void *user_data, const char *data, unsigned length, bool overflow), void *user_data)
This function allows settings a callback that is called with raw sequences before interpretation. The application can
inspect the sequences in this callback. If the callback returns true the sequence is not interpreted further.
This is mostly a wrapper for using :c:func:`termpaint_input_set_raw_filter_cb` with a terminal object. But events
while running terminal auto detection are not passed to the given callback.
.. c:function:: void termpaint_terminal_handle_paste(termpaint_terminal *term, _Bool enabled)
This is a wrapper for using :c:func:`termpaint_input_handle_paste` with a terminal object.
Explicit paste handling is an switchable terminal feature, see
:c:func:`termpaint_terminal_request_tagged_paste` for enabling it.
.. c:function:: const char *termpaint_terminal_self_reported_name_and_version(const termpaint_terminal *terminal)
Returns a pointer to a string with the result of the terminal's self reported name and version. Only some terminals
support this. For other terminals NULL will be returned.
This value is only available after successful terminal auto-detection. The returned pointer is valid until the
terminal object is freed or terminal auto detection is triggered again.
.. c:function:: void termpaint_terminal_auto_detect_result_text(const termpaint_terminal *terminal, char *buffer, int buffer_length)
Fills ``buffer`` with null terminated string with debugging details about the detected terminal type.
The buffer pointed to by ``buffer`` needs to be at least ``buffer_length`` bytes long.
.. c:function:: void termpaint_terminal_activate_input_quirk(termpaint_terminal *term, int quirk)
This is a wrapper for using :c:func:`termpaint_input_activate_quirk` with a terminal object.
Quirks matching the auto detected terminal are already activated by
:c:func:`termpaint_terminal_auto_detect_apply_input_quirks`.
Calling this function explicitly should be rarely needed.
.. c:function:: const char* termpaint_terminal_peek_input_buffer(const termpaint_terminal *term)
This function in conjunction with :c:func:`termpaint_terminal_peek_input_buffer_length` allows an application
to observe input data that is buffered by not yet processed. If called after :c:func:`termpaint_terminal_add_input_data`
returned, this will contain data in partial or ambiguous sequences not yet processed.
This is a wrapper for using :c:func:`termpaint_input_peek_buffer` with a terminal object.
.. c:function:: int termpaint_terminal_peek_input_buffer_length(const termpaint_terminal *term)
Returns the length of the valid data for :c:func:`termpaint_terminal_peek_input_buffer`.
This is a wrapper for using :c:func:`termpaint_input_peek_buffer_length` with a terminal object.
.. c:function:: void termpaint_terminal_set_log_mask(termpaint_terminal *term, unsigned mask)
Set the mask of what besides errors is reported to the integration's logging callback.
All logging messages are for debugging only and might change between releases.
``mask`` is a bit combination of
.. c:namespace:: 0
.. c:macro:: TERMPAINT_LOG_AUTO_DETECT_TRACE
Log details of the auto detection state machine
.. c:macro:: TERMPAINT_LOG_TRACE_RAW_INPUT
Log raw input bytes from the terminal.
.. c:function:: _Bool termpaint_terminal_capable(const termpaint_terminal *terminal, int capability)
Features supported differ among terminal implementations. Termpaint uses as set of capabilities to decide
how to interface with terminals. This function allows to query currently set capabilities.
Capabilities start with some defaults and get setup during terminal auto-detection.
The following capabilities are available:
.. c:namespace:: 0
.. c:macro:: TERMPAINT_CAPABILITY_7BIT_ST
The terminals fully supports using ``ESC\\`` as string terminator. This is the string terminator
specified by ECMA-48.
.. c:macro:: TERMPAINT_CAPABILITY_88_COLOR
The terminal uses 88 colors for indexed colors instead of the more widely supported 256 colors.
.. c:macro:: TERMPAINT_CAPABILITY_CLEARED_COLORING
The terminal supports using "clear to end of line" for trailing sequences of insignificant
spaces. This includes support for setting up multiple colored ranges per line using this
sequence.
.. c:macro:: TERMPAINT_CAPABILITY_CLEARED_COLORING_DEFCOLOR
If TERMPAINT_CAPABILITY_CLEARED_COLORING is supported this indicated if this sequence also
works for the special "default" terminal color.
.. c:macro:: TERMPAINT_CAPABILITY_CSI_EQUALS
The terminal's escape sequence parser properly handles sequences starting with ``ESC[=``
and ignores unknown sequences of this type.
.. c:macro:: TERMPAINT_CAPABILITY_CSI_GREATER
The terminal's escape sequence parser properly handles sequences starting with ``ESC[>``
and ignores unknown sequences of this type.
.. c:macro:: TERMPAINT_CAPABILITY_CSI_POSTFIX_MOD
The terminal's escape sequence parser properly handles sequences that use a intermediate
character before the final character of a CSI sequence.
.. c:macro:: TERMPAINT_CAPABILITY_CURSOR_SHAPE_OSC50
Cursor shape needs to be setup with a konsole specific escape sequence.
.. c:macro:: TERMPAINT_CAPABILITY_EXTENDED_CHARSET
The terminal is capable of displaying a font with more than 512 different characters.
.. c:macro:: TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE
The terminal's parser is expected to cope with the cursor setup CSI sequence without
glitches.
.. c:macro:: TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE_BAR
The terminal either does not support cursor shapes or it does support bar cursor shape.
.. c:macro:: TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE
The terminal supports bracketed/tagged paste.
.. c:macro:: TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT
The terminal uses a format for cursor position reports that is distinct from key press reports.
.. c:macro:: TERMPAINT_CAPABILITY_TITLE_RESTORE
The terminal has a title stack that can be used to restore the title.
.. c:macro:: TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED
The terminal is not known to have problems with rgb(truecolor) color types.
.. c:macro:: TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED
The terminal is known to support rgb(truecolor) color types.
.. c:function:: void termpaint_terminal_promise_capability(termpaint_terminal *terminal, int capability)
This function allows overriding terminal type auto-detection of terminal capabilities.
Use this with care, if the terminal is not able to handle the enabled capabilities the rendering might
break.
.. c:function:: void termpaint_terminal_disable_capability(termpaint_terminal *terminal, int capability)
This function allows overriding terminal type auto-detection of terminal capabilities.
On specific use is to disable :c:macro:`TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED` to switch to
a more conservative estamination of a terminals capability to support rgb color modes.
.. c:function:: void termpaint_terminal_expect_apc_input_sequences(termpaint_terminal *term, _Bool enabled)
This is a wrapper for using :c:func:`termpaint_input_expect_apc_sequences` with a terminal object.
APC sequences are only known to be used by kitty in an extended keyboard reporting mode that is currently
not supported by termpaint.
.. c:function:: void termpaint_terminal_expect_cursor_position_report(termpaint_terminal *term)
This is a wrapper for using :c:func:`termpaint_input_expect_cursor_position_report` with a terminal object.
Needs to be called for each ``ESC[6n`` sequence send manually to the terminal to ensure the result is
interpreted as cursor position report instead of a key press.
If the terminal :c:macro:`properly supports ESC[?6n` that sequence
should be used and this function does
not need to be called.
.. c:function:: void termpaint_terminal_expect_legacy_mouse_reports(termpaint_terminal *term, int s)
This is a wrapper for using :c:func:`termpaint_input_expect_legacy_mouse_reports` with a terminal object.
When mouse reporting is enabled this function is internally called with
:c:macro:`TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE`, so it should be rarely needed to call this explicitly.
.. c:function:: void termpaint_terminal_glitch_on_out_of_memory(termpaint_terminal *term)
Normally termpaint aborts the process on memory allocation failure to avoid hard to debug glitches.
When this function is called instead termpaint tries to continue, but potentially discarding output
characters and attributes where allocation would be needed.
Call this function if your application needs to be resilient against memory allocation failures.
To use termpaint in such environments it's additionally required to call variants of functions ending
in _or_nullptr or _mustcheck instead of the base variant whenever those exist in the header file.
See :ref:`malloc-failure` for details.
Functions for integrations
--------------------------
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: const char *termpaint_terminal_restore_sequence(const termpaint_terminal *term)
Returns a null terminated string that can be used to restore the terminal to it's base state.
The restore string is the same string that is used when calling
:c:func:`termpaint_terminal_free_with_restore` or :c:func:`termpaint_terminal_pause`.
.. c:function:: void termpaint_terminal_callback(termpaint_terminal *term)
If the application has set ``request_callback`` in the integration structure, this function needs to be called after
a delay when the terminal object requests it by invoking the ``request_callback`` callback.
.. c:function:: void termpaint_terminal_add_input_data(termpaint_terminal *term, const char *data, unsigned length)
The integration part of the application has to call this function to pass terminal input data to the terminal object.
See :doc:`integration` for details.
The application has to ensure that this function is never called recursively from a callback
with any :c:type:`termpaint_input` object that is already in a call to ``termpaint_terminal_add_input_data``.
This is a wrapper for using :c:func:`termpaint_input_add_data` with a terminal object.
termpaint-0.3.1/doc/termpaint_input.rst 0000664 0000000 0000000 00000016302 14773035472 0020255 0 ustar 00root root 0000000 0000000 termpaint_input
===============
.. c:type:: termpaint_input
``termpaint_input`` is a sublibrary for terminal input handling. It can be used standalone, but when using termpaint for
terminal output it's always used as an internal dependency.
Thus while standalone usage is fully supported, most applications will not use it explicitly. Where interaction with the
input handling is needed there are wrappers that take a :c:type:`termpaint_terminal` object and forward settings to the
internal instance.
.. TODO general API design
Input bytes from the terminal to termpaint_input need to be passed to :c:func:`termpaint_input_add_data`. If enough
bytes have accumulated to identify a input sequence termpaint_input will call the event callback set by the application
using :c:func:`termpaint_input_set_event_cb` with the interpreted :doc:`event `.
Functions
---------
These functions are contained in the header ``termpaintx_input.h``
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: termpaint_input *termpaint_input_new(void)
Create a new termpaint_input object.
The application has to free this with :c:func:`termpaint_input_free`
.. c:function:: void termpaint_input_free(termpaint_input *ctx)
Frees the termpaint_input object ``ctx``.
.. c:function:: void termpaint_input_set_event_cb(termpaint_input *ctx, void (*cb)(void *user_data, termpaint_event* event), void *user_data)
The application must use this function to set an event callback. See :doc:`events` for details about events produced
by terminal input. The input is buffered and as soon as a complete sequence is detected the raw filter callback is
invoked and if that callback didn't suppress further processing an an event is generated and passed to the event
callback.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_set_event_cb`
.. c:function:: void termpaint_input_add_data(termpaint_input *ctx, const char *data, unsigned length)
This is the function to feed incoming data from the terminal to the input processing.
The application has to ensure that this function is never called recursively from a callback
with any :c:type:`termpaint_input` object that is already in a call to ``termpaint_input_add_data``.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_add_input_data`
.. c:function:: void termpaint_input_set_raw_filter_cb(termpaint_input *ctx, _Bool (*cb)(void *user_data, const char *data, unsigned length, _Bool overflow), void *user_data)
This function allows settings a callback that is called with raw sequences before interpretation. The application can
inspect the sequence in this callback. If the callback returns true the sequence is not interpreted further.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_set_raw_input_filter_cb`
.. c:function:: void termpaint_input_expect_cursor_position_report(termpaint_input *ctx)
Needs to be called for each ``ESC[6n`` sequence send to the terminal to ensure the result is
interpreted as cursor position report instead of a key press.
This should not be called if ``ESC[?6n`` is used and properly supported by the terminal.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_expect_cursor_position_report`
.. c:function:: void termpaint_input_expect_legacy_mouse_reports(termpaint_input *ctx, int s)
Legacy mouse modes use sequences that do not fit into the ECMA-48 sequence schema. They are composed of ``ESC[M``
followed by additional data. The original mouse reporting modes use this kind of encoding. An additional mode was
defined later that can not reliably differentiated thus apart from "off" there are two choices.
.. c:namespace:: 0
.. c:macro:: TERMPAINT_INPUT_EXPECT_NO_LEGACY_MOUSE
Disable parsing of legacy mouse sequences.
.. c:macro:: TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE
Expect legacy mouse sequences in the original format composed of 3 bytes following the ``ESC[M`` sequence.
.. c:macro:: TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE_MODE_1005
Expect legacy mouse sequences in the multibyte format similar to 2 byte utf-8 encoding. The ``ESC[M`` sequence is
followed by 3 of these variable length representations. This encoding is commonly selected using `ESC[?1005h`.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_expect_legacy_mouse_reports`
.. c:function:: void termpaint_input_handle_paste(termpaint_input *ctx, _Bool enable)
Set whether bracketed paste terminal sequences are parsed as a :c:macro:`TERMPAINT_EV_PASTE`
event (if ``enable`` is true) or if the contents of the paste is parsed like normal input,
sandwiched in :c:macro:`TERMPAINT_EV_MISC` events with atoms :c:func:`termpaint_input_paste_begin`
and :c:func:`termpaint_input_paste_end`.
Explicit paste handling is an switchable terminal feature, this setting only is meaningful
if bracketed paste has been enabled in the terminal.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_handle_paste`
.. c:function:: void termpaint_input_expect_apc_sequences(termpaint_input *ctx, _Bool enable)
Consider input starting with ``ESC_`` as a sequence to be terminated by a string terminator (ST) instead of as
alt ``_``. The resync trick will still detect ``ESC_`` if it's followed by ``ESC[0n``.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_expect_apc_input_sequences`
.. c:function:: const char* termpaint_input_peek_buffer(const termpaint_input *ctx)
This function in conjunction with :c:func:`termpaint_input_peek_buffer_length` allows an application
to observe input data that is buffered by not yet processed. If called after :c:func:`termpaint_input_add_data`
returned, this will contain data in partial or ambiguous sequences not yet processed.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_peek_input_buffer`
.. c:function:: int termpaint_input_peek_buffer_length(const termpaint_input *ctx)
Returns the length of the valid data for :c:func:`termpaint_input_peek_buffer`.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_peek_input_buffer_length`
.. c:function:: void termpaint_input_activate_quirk(termpaint_input *ctx, int quirk)
Most input parsing is independent of the connected terminal. But some sequences are used by different terminals for
different functions. In that case quirks allow fine tuning the input parsing to pick the correct interpretation.
.. c:namespace:: 0
.. c:macro:: TERMPAINT_INPUT_QUIRK_BACKSPACE_X08_AND_X7F_SWAPPED
Without this quirk char 0x7f (DEL) is interpreted as backspace key and char 0x08 (ASCII BS) is interpreted as
ctrl backspace.
With this quirk activated the interpretation is swapped.
.. c:macro:: TERMPAINT_INPUT_QUIRK_C1_FOR_CTRL_SHIFT
By default C1 control characters are not interpreted as special key input. When this quirk is activated char
0x80 is interpreted as ctrl shift space and chars 0x81 to 0x9a are interpreted as ctrl shift A-Z.
The wrapper for using this with a terminal object is :c:func:`termpaint_terminal_activate_input_quirk`
termpaint-0.3.1/doc/termpaintx.rst 0000664 0000000 0000000 00000041645 14773035472 0017236 0 ustar 00root root 0000000 0000000 Addon termpaintx
================
termpaintx is an optional add-on to termpaint that offers a very simple
premade integration and a few functions that might be useful for custom
integrations.
For applications that deal with any kind of asynchronous events, apart from
the terminal, it’s recommended to use a custom integration or an external
integration into a general event loop. But for simple applications that only
deal with synchronous data sources and time based events this simple
integration can be used.
termpaintx has operating system specific dependencies and might not be
available for all compilation environments.
The free callback of this integration frees the memory used, thus
termpaint_terminal_new takes ownership of the integration.
..
For simple synchronous applications termpaintx contains a functional integration. This integration does not support
additional communication devices or connections.
..
An example using this integration looks like this::
..
termpaint_integration *integration = termpaintx_full_integration("+kbdsigint +kbdsigtstp");
termpaint_terminal *terminal = termpaint_terminal_new(integration);
termpaint_terminal_set_event_cb(terminal, event_callback, NULL);
termpaintx_full_integration_set_terminal(integration, terminal);
termpaint_terminal_auto_detect(terminal);
termpaintx_full_integration_wait_for_ready(integration);
termpaintx_full_integration_apply_input_quirks(integration);
int width, height;
termpaintx_full_integration_terminal_size(integration, &width, &height);
termpaint_terminal_setup_fullscreen(terminal, width, height, "+kbdsig");
..
// use terminal here
..
while (!quit) {
if (!termpaint_full_integration_do_iteration(integration)) {
// some kind of error
break;
}
// either do work here or from the event_callback.
}
..
termpaint_terminal_free_with_restore(terminal);
These functions are contained in the header ``termpaintx.h``
.. c:function:: _Bool termpaintx_full_integration_available()
Checks if the program is connected to a terminal.
(using `isatty(3) `__)
This function checks if :c:func:`termpaintx_full_integration` will likely succeed.
.. _termpaintx-options:
.. c:function:: termpaint_integration *termpaintx_full_integration(const char *options)
Creates an integration object with the given options. It tries finding a connected
terminal by looking at stdin, stdout, stderr and the process' controlling terminal.
``options`` is a space separated list of options.
Supported options:
``+kbdsigint``
Do not disable kernel keyboard interrupt handling (usually Ctrl-C)
``+kbdsigquit``
Do not disable kernel keyboard quit handling (usually Ctrl-\\)
``+kbdsigtstp``
Do not disable kernel keyboard suspend handling (usually Ctrl-Z)
This integration does not offer any support for handling the needed SIGTSTP signal for
proper suspend support. It's your applications responsibility to supply the needed signal
handling.
If an application wants to support keyboard suspend it has to arrange for a signal handler
to restore the terminal and call :c:func:`termpaint_terminal_unpause` after the process
is resumed and the kernel terminal interface is again configured for termpaint usage.
Returns NULL on failure.
Handling of the WINCH (window size changed) signal is automatically setup if possible.
.. c:function:: termpaint_integration *termpaintx_full_integration_from_controlling_terminal(const char *options)
Creates an integration object with the given options. It tries finding a connected
terminal by looking at the process' controlling terminal.
Returns NULL on failure.
Handling of the WINCH (window size changed) signal is automatically setup.
See :ref:`here` for allowed values of the ``options`` parameter.
.. c:function:: termpaint_integration *termpaintx_full_integration_from_fd(int fd, _Bool auto_close, const char *options)
Creates an integration object with the given options. It uses file descriptor ``fd``. If ``auto_close`` is true, the
file descriptor will be closed when the integration is deallocated.
The application is responsible to detect terminal size changes and call
:c:func:`termpaint_surface_resize` on the primary surface with the new size.
See :ref:`here` for allowed values of the ``options`` parameter.
.. c:function:: termpaint_integration *termpaintx_full_integration_from_fds(int fd_read, int fd_write, const char *options)
Creates an integration object with the given options. It uses file descriptor ``fd_read`` for reading from the
terminal and ``fd_write`` for writing to the terminal.
The application is responsible to detect terminal size changes and call
:c:func:`termpaint_surface_resize` on the primary surface with the new size.
See :ref:`here` for allowed values of the ``options`` parameter.
.. c:function:: termpaint_integration *termpaintx_full_integration_setup_terminal_fullscreen(const char *options, void (*event_handler)(void *, termpaint_event *), void *event_handler_user_data, termpaint_terminal **terminal_out)
Creates an integration and a terminal object with the given options and connects them to work together.
The integration is returned and the terminal object is made available via the ``terminal`` out-parameter.
It also runs terminal auto-detection and applies detected input processing quirks, initializes full screen
mode using :c:func:`termpaint_terminal_setup_fullscreen()` and sets up a watchdog process to restore the terminal to
it's normal state if the main application suddenly terminates (e.g. a crash).
The ``event_handler`` and ``event_handler_user_data`` are passed to :c:func:`termpaint_terminal_set_event_cb`.
Valid options are :ref:`options for termpaint` and
:ref:`options for termpaintx`.
If the integration can not be initialized then the function prints an error message and returns NULL.
This function is currently equivalent to a manual setup like this::
termpaint_integration *integration = termpaintx_full_integration(options);
if (!integration) {
const char* error = "Error: Terminal not available!";
write(1, error, strlen(error));
return nullptr;
}
termpaint_terminal *terminal = termpaint_terminal_new(integration);
termpaintx_full_integration_set_terminal(integration, terminal);
termpaint_terminal_set_event_cb(terminal, event_handler, event_handler_user_data);
termpaint_terminal_auto_detect(terminal);
termpaintx_full_integration_wait_for_ready_with_message(integration, 10000,
"Terminal auto detection is taking unusually long, press space to abort.");
termpaintx_full_integration_apply_input_quirks(integration);
int width, height;
termpaintx_full_integration_terminal_size(integration, &width, &height);
termpaint_terminal_setup_fullscreen(terminal, width, height, options);
termpaintx_full_integration_ttyrescue_start(integration);
.. c:function:: termpaint_integration *termpaintx_full_integration_setup_terminal_inline(const char *options, int lines, void (*event_handler)(void *, termpaint_event *), void *event_handler_user_data, termpaint_terminal **terminal_out)
Creates an integration and a terminal object with the given options and connects them to work together.
The integration is returned and the terminal object is made available via the ``terminal`` out-parameter.
It also runs terminal auto-detection and applies detected input processing quirks, initializes inline
mode using :c:func:`termpaint_terminal_setup_inline()` and sets up a watchdog process to restore the terminal to
it's normal state if the main application suddenly terminates (e.g. a crash).
The height of the inline rendering area is set to ``lines`` high.
The ``event_handler`` and ``event_handler_user_data`` are passed to :c:func:`termpaint_terminal_set_event_cb`.
Valid options are :ref:`options for termpaint` and
:ref:`options for termpaintx`.
If the integration can not be initialized then the function prints an error message and returns NULL.
The steps are similar to :c:func:`termpaintx_full_integration_setup_terminal_fullscreen` except that
termpaint_terminal_setup_inline is used and the height passed to it is limited to `lines`.
.. c:function:: _Bool termpaintx_full_integration_do_iteration(termpaint_integration *integration)
Waits for input from the terminal and passes it to the connected terminal object.
Return false, if an error occurred while reading from the input file descriptor.
.. c:function:: _Bool termpaintx_full_integration_do_iteration_with_timeout(termpaint_integration *integration, int *milliseconds)
Waits for input from the terminal for ``*milliseconds`` milliseconds and passes it to the connected terminal object.
After the call ``*milliseconds`` will contain the remaining milliseconds from the original timeout. If the call
returned because the timeout expired ``*milliseconds`` will be zero, otherwise it will be the original value minus the
time spend waiting for and processing input.
Return false, if an error occurred while reading from the input file descriptor.
.. c:function:: void termpaintx_full_integration_wait_for_ready(termpaint_integration *integration)
Waits for the auto-detection to be finished. It internally calls :c:func:`termpaintx_full_integration_do_iteration`
while waiting.
.. c:function:: void termpaintx_full_integration_wait_for_ready_with_message(termpaint_integration *integration, int milliseconds, const char* message)
Like :c:func:`termpaintx_full_integration_wait_for_ready` but if detection did not finish after `milliseconds`
milliseconds, will print ``message``.
Please note, printing a message while fingerprinting is in it's start phase might interfere with fingerprinting. So
don't use too small values for ``milliseconds``. Nevertheless a timeout can help for terminals that are not compatible
with running terminal autodetection, by at least altering the user that something likly has gone wrong.
.. c:function:: void termpaintx_full_integration_apply_input_quirks(termpaint_integration *integration)
Setup input handling based on the auto detection result and tty parameters.
Needs to be called after auto detection is finished.
It internally calls :c:func:`termpaint_terminal_auto_detect_apply_input_quirks`
.. c:function:: void termpaintx_full_integration_set_terminal(termpaint_integration *integration, termpaint_terminal *terminal)
Sets the terminal object to be managed by this integration object. This needs to be called before using
:c:func:`termpaintx_full_integration_do_iteration` when not using
:c:func:`termpaintx_full_integration_setup_terminal_fullscreen` (which already does that).
.. c:function:: const struct termios *termpaintx_full_integration_original_terminal_attributes(termpaint_integration *integration)
Returns a pointer to the saved terminal attributes in ``termios`` format. The pointer is valid until the integration
is freed.
Note: As all functions in termpaint this function is not async-signal safe. If the application needs this information
in a signal handler it needs to call this function while initializing and store the value for the signal handler to use.
.. c:function:: void termpaintx_full_integration_set_inline(termpaint_integration *integration, _Bool enabled, int height)
Sets the inline status and inline height for the associated terminal.
If ``enabled`` is true, the terminal is set to inline mode and resized to the height given in ``height`` (or the
size of the connected terminal if ``height`` is larger).
In contrast to :c:func:`termpaint_terminal_set_inline` this function updates essential state in termpaintx needed for
handling terminal resize.
A call to this function must be followed by reestablishing the primary surface contents and
by a call to :c:func:`termpaint_terminal_flush()` to finalize the switch to the new mode.
On manual terminal initializations (i.e. using :c:func:`termpaint_terminal_setup_inline` instead of
:c:func:`termpaintx_full_integration_setup_terminal_inline`) of inline mode, this function may also be used to
synchronize termpaintx internal state to inline state of termpaint, if used with ``enabled`` is true and ``height`` is
greater than zero.
.. c:function:: _Bool termpaintx_full_integration_ttyrescue_start(termpaint_integration *integration)
Sets up a watchdog process to restore the terminal to it’s normal state if the
main application suddenly terminates (e.g. a crash).
Returns false on failure.
.. c:function:: _Bool termpaintx_full_integration_terminal_size(termpaint_integration *integration, int *width, int *height)
Stores the current terminal size into ``*width`` and ``*height``. This function relies on the terminal size cached in
the kernel.
Returns false on failure.
.. c:function:: termpaint_logging_func termpaintx_enable_tk_logging(void)
This function starts a helper process that uses python3 to create a window (using
`tkinter `_ with logging messages. The window will appear when
the first log message is output.
It returns a function suitable as logging callback for a integration.
If an error occurred setting up the helper process returns a no-op logging function.
This function is meant to easy development and debugging of an application using termpaint. It's not meant
for usage in the final application.
This function is only available if enabled at compile time.
Functions for custom integrations
---------------------------------
.. c:function:: _Bool termpaintx_fd_set_termios(int fd, const char *options)
This function can be used to get the kernel terminal setup without using the full integration.
Instead of a pointer to an integration object this accesses the terminal directly by the file
descriptor ``fd``.
It accepts the same options as :c:func:`termpaintx_full_integration`
Returns false on failure.
.. c:function:: _Bool termpaintx_fd_terminal_size(int fd, int *width, int *height)
This function can be used to get the terminal size from the kernel without using the full integration.
Instead of a pointer to an integration object this accesses the terminal directly by the file
descriptor ``fd``.
Otherwise it works like :c:func:`termpaintx_full_integration_terminal_size`.
Returns false on failure.
Terminal restore watchdog
-------------------------
.. c:type:: termpaintx_ttyrescue
termpaintx has a functions to create a watchdog subprocess to restore the terminal to a usable state
on sudden program termination (e.g. a crash).
This watchdog process uses a socket pair (similar to a pipe) to monitor that the main process is
still running. If the main process terminates without first signaling a clean shutdown by calling
:c:func:`termpaintx_ttyrescue_stop` the watchdog restores the terminal and kernel interface settings.
When using the integration from termpaintx the watchdog is started by calling
:c:func:`termpaintx_full_integration_ttyrescue_start`. The integration takes care of updating
the restore sequence as it changes over time and communicating the original kernel terminal
interface layer settings to the watchdog. The watchdog is automatically shut down, when the
integration is freed.
If the watchdog is used with a custom terminal integration it is started using
:c:func:`termpaintx_ttyrescue_start_or_nullptr`, passing it the initial restore sequence and the file
descriptor of the terminal. The integration has to call
:c:func:`termpaintx_ttyrescue_set_restore_termios` to set the original ``struct termios``
contents and if the restore sequence changes it has to call :c:func:`termpaintx_ttyrescue_update`
with the new restore sequence.
Functions
.........
These functions are contained in the header ``termpaintx_ttyrescue.h``
See :ref:`safety` for general rules for calling functions in termpaint.
.. c:function:: termpaintx_ttyrescue *termpaintx_ttyrescue_start_or_nullptr(int fd, const char *restore_seq)
Setup the watchdog process. The watchdog uses terminal file descriptor ``fd`` when a restore is triggered,
sending the string ``restore_seq`` to the terminal.
Returns ``NULL`` on error.
.. c:function:: void termpaintx_ttyrescue_stop(termpaintx_ttyrescue *tpr)
Cleanly stop the watchdog process.
.. c:function:: _Bool termpaintx_ttyrescue_update(termpaintx_ttyrescue *tpr, const char* data, int len)
Update the restore sequence used by the watchdog process.
Returns false on failure.
.. c:function:: _Bool termpaintx_ttyrescue_set_restore_termios(termpaintx_ttyrescue *tpr, const struct termios *original_terminal_attributes)
Set or update the ``struct termios`` to reset the terminal kernel interface to when the watchdog triggers.
Returns false on failure.
termpaint-0.3.1/filetoinc.py 0000775 0000000 0000000 00000001433 14773035472 0016064 0 ustar 00root root 0000000 0000000 #! /usr/bin/env python3
# SPDX-License-Identifier: BSL-1.0
import sys
name = sys.argv[1]
infile = sys.argv[2]
outfile = sys.argv[3]
with open(infile, 'rb') as f:
data = f.read()
data_encoded = [""]
# intentionally excluding some whitespace and some special characters
basic_c_source_chars = set(b' abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_{}[]#()<>%:;.?*+-/^&|~!=,\'')
for ch in data:
if ch in basic_c_source_chars:
data_encoded[-1] += chr(ch)
else:
data_encoded[-1] += "\\{:o}".format(ch)
if len(data_encoded[-1]) > 70:
data_encoded.append("")
with open(outfile, 'w') as f:
f.write('static const unsigned char {}[] = {{\n'.format(name))
for line in data_encoded:
f.write(' "{}"\n'.format(line))
f.write('};\n')
termpaint-0.3.1/inputevents.cpp 0000664 0000000 0000000 00000036400 14773035472 0016625 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#include
#include
#include
#include
#include
#include
#include
#include
typedef bool _Bool;
#include "termpaint.h"
#include "termpaintx.h"
#include "termpaint_input.h"
#include "termpaintx_ttyrescue.h"
struct DisplayEvent {
std::string raw;
std::string eventString;
};
std::vector ring;
std::string peek_buffer;
termpaint_terminal *terminal;
termpaint_surface *surface;
time_t last_q;
bool m_mode;
bool quit;
bool focus_tracking = false;
bool tagged_paste = false;
bool raw_paste = false;
bool legacy_mouse_support = false;
bool apc_parsing = false;
bool raw_command_mode = false;
std::string raw_commmand_str;
std::string terminal_info;
template
unsigned char u8(X); // intentionally undefined
template <>
unsigned char u8(char ch) {
return ch;
}
_Bool raw_filter(void *user_data, const char *data, unsigned length, _Bool overflow) {
(void)user_data; (void)overflow;
std::string event { data, length };
ring.emplace_back();
ring.back().raw = event;
if (event == "q") {
time_t now = time(0);
if (last_q && (now - last_q) == 3) {
quit = true;
}
last_q = now;
} else {
last_q = 0;
}
if (m_mode) {
m_mode = false;
if (event == "0") {
termpaint_terminal_set_mouse_mode(terminal, TERMPAINT_MOUSE_MODE_OFF);
} else if (event == "1") {
termpaint_terminal_set_mouse_mode(terminal, TERMPAINT_MOUSE_MODE_CLICKS);
} else if (event == "2") {
termpaint_terminal_set_mouse_mode(terminal, TERMPAINT_MOUSE_MODE_DRAG);
} else if (event == "3") {
termpaint_terminal_set_mouse_mode(terminal, TERMPAINT_MOUSE_MODE_MOVEMENT);
} else if (event == "4") {
focus_tracking = !focus_tracking;
termpaint_terminal_request_focus_change_reports(terminal, focus_tracking);
} else if (event == "6") {
legacy_mouse_support = !legacy_mouse_support;
termpaint_terminal_expect_legacy_mouse_reports(terminal, legacy_mouse_support);
} else if (event == "p") {
tagged_paste = !tagged_paste;
termpaint_terminal_request_tagged_paste(terminal, tagged_paste);
} else if (event == "r") {
raw_paste = !raw_paste;
termpaint_terminal_handle_paste(terminal, !raw_paste);
} else if (event == "a") {
apc_parsing = !apc_parsing;
termpaint_terminal_expect_apc_input_sequences(terminal, apc_parsing);
} else if (event == "x") {
raw_commmand_str = "";
raw_command_mode = true;
} else if (event == "q") {
quit = true;
}
} else if (raw_command_mode) {
if (event[1] == 0 && event[0] >= ' ' && event[0] <= 126) {
raw_commmand_str += event;
}
if (event == "\x0d") {
raw_command_mode = false;
if (raw_commmand_str.size()) {
printf("%s", "\033[0;0H\033");
printf("%s", raw_commmand_str.data());
fflush(stdout);
sleep(1);
}
}
if (event == "\x08" || event == "\x7f") {
if (raw_commmand_str.size()) {
raw_commmand_str.pop_back();
}
}
} else {
if (event == "m") {
m_mode = true;
}
}
return 0;
}
void event_handler(void *user_data, termpaint_event *event) {
(void)user_data;
std::string pretty;
if (event->type == 0) {
pretty = "unknown";
} else if (event->type == TERMPAINT_EV_KEY) {
pretty = "K: ";
if ((event->key.modifier & ~(TERMPAINT_MOD_SHIFT|TERMPAINT_MOD_ALT|TERMPAINT_MOD_CTRL)) == 0) {
pretty += (event->key.modifier & TERMPAINT_MOD_SHIFT) ? "S" : " ";
pretty += (event->key.modifier & TERMPAINT_MOD_ALT) ? "A" : " ";
pretty += (event->key.modifier & TERMPAINT_MOD_CTRL) ? "C" : " ";
} else {
char buf[100];
snprintf(buf, 100, "%03d", event->key.modifier);
pretty += buf;
}
pretty += " ";
pretty += std::string { event->key.atom, event->key.length };
} else if (event->type == TERMPAINT_EV_CHAR) {
pretty = "C: ";
pretty += (event->c.modifier & TERMPAINT_MOD_SHIFT) ? "S" : " ";
pretty += (event->c.modifier & TERMPAINT_MOD_ALT) ? "A" : " ";
pretty += (event->c.modifier & TERMPAINT_MOD_CTRL) ? "C" : " ";
pretty += " ";
pretty += std::string { event->c.string, event->c.length };
} else if (event->type == TERMPAINT_EV_MOUSE) {
if ((event->mouse.modifier & ~(TERMPAINT_MOD_SHIFT|TERMPAINT_MOD_ALT|TERMPAINT_MOD_CTRL)) == 0) {
pretty += (event->mouse.modifier & TERMPAINT_MOD_SHIFT) ? "S" : " ";
pretty += (event->mouse.modifier & TERMPAINT_MOD_ALT) ? "A" : " ";
pretty += (event->mouse.modifier & TERMPAINT_MOD_CTRL) ? "C" : " ";
} else {
char buf[100];
snprintf(buf, 100, "%03d", event->mouse.modifier);
pretty += buf;
}
pretty += " Mouse ";
if (event->mouse.action == TERMPAINT_MOUSE_PRESS) {
pretty += std::to_string(event->mouse.button) + " press";
} else if (event->mouse.action == TERMPAINT_MOUSE_MOVE) {
pretty += "move";
} else if (event->mouse.button != 3) {
pretty += std::to_string(event->mouse.button) + " release";
} else {
pretty += "some release";
}
pretty += ": x=" + std::to_string(event->mouse.x) + " y=" + std::to_string(event->mouse.y)
+ " rawbtn=" + std::to_string(event->mouse.raw_btn_and_flags);
} else if (event->type == TERMPAINT_EV_MISC) {
pretty += "Misc: ";
pretty += std::string { event->misc.atom, event->misc.length };
} else if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
pretty = "Cursor position report: x=" + std::to_string(event->cursor_position.x) + " y=" + std::to_string(event->cursor_position.y);
} else if (event->type == TERMPAINT_EV_MODE_REPORT) {
if (event->mode.kind & 1) {
pretty = "Mode status report: mode=?" + std::to_string(event->mode.number) + " status=" + std::to_string(event->mode.status);
} else {
pretty = "Mode status report: mode=" + std::to_string(event->mode.number) + " status=" + std::to_string(event->mode.status);
}
} else if (event->type == TERMPAINT_EV_PASTE) {
pretty = "Paste: ";
pretty += (event->paste.initial) ? "I" : " ";
pretty += (event->paste.final) ? "F" : " ";
pretty += " ";
std::string pasted = std::string { event->paste.string, event->paste.length };
pretty += "\"";
for (auto ch : pasted) {
if (ch < ' ') {
pretty += "\\x" + std::to_string(ch);
} else if (ch == '\\') {
pretty += "\\x5c";
} else {
pretty.append(1, ch);
}
}
pretty += "\"";
} else {
pretty = "Other event no. " + std::to_string(event->type);
}
if (ring.empty() || ring.back().eventString.size()) {
ring.emplace_back();
}
ring.back().eventString = pretty;
}
const auto rgb_white = TERMPAINT_RGB_COLOR(0xff, 0xff, 0xff);
const auto rgb_greyCC = TERMPAINT_RGB_COLOR(0xcc, 0xcc, 0xcc);
const auto rgb_grey7F = TERMPAINT_RGB_COLOR(0x7f, 0x7f, 0x7f);
const auto rgb_black = TERMPAINT_RGB_COLOR(0, 0, 0);
const auto rgb_redFF = TERMPAINT_RGB_COLOR(0xff, 0, 0);
const auto rgb_red7F = TERMPAINT_RGB_COLOR(0xff, 0, 0);
void display_esc(int x, int y, const std::string &data) {
for (unsigned i = 0; i < data.length(); i++) {
if (u8(data[i]) == '\033') {
termpaint_surface_write_with_colors(surface, x, y, "^[", rgb_white, rgb_red7F);
x+=2;
} else if (0xfc == (0xfe & u8(data[i])) && i+5 < data.length()) {
char buf[7] = {data[i], data[i+1], data[i+2], data[i+3], data[i+4], data[i+5], 0};
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_grey7F);
x += 1;
i += 5;
} else if (0xf8 == (0xfc & u8(data[i])) && i+4 < data.length()) {
char buf[7] = {data[i], data[i+1], data[i+2], data[i+3], data[i+4], 0};
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_grey7F);
x += 1;
i += 4;
} else if (0xf0 == (0xf8 & u8(data[i])) && i+3 < data.length()) {
char buf[7] = {data[i], data[i+1], data[i+2], data[i+3], 0};
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_grey7F);
x += 1;
i += 3;
} else if (0xe0 == (0xf0 & u8(data[i])) && i+2 < data.length()) {
char buf[7] = {data[i], data[i+1], data[i+2], 0};
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_grey7F);
x += 1;
i += 2;
} else if (0xc0 == (0xe0 & u8(data[i])) && i+1 < data.length()) {
if (((unsigned char)data[i]) == 0xc2 && ((unsigned char)data[i+1]) < 0xa0) { // C1 and non breaking space
char v = ((unsigned char)data[i+1]) >> 4;
char a = char(v < 10 ? '0' + v : 'a' + v - 10);
v = data[i+1] & 0xf;
char b = char(v < 10 ? '0' + v : 'a' + v - 10);
char buf[7] = {'\\', 'u', '0', '0', a, b, 0};
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_red7F);
x += 6;
} else {
char buf[7] = {data[i], data[i+1], 0};
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_grey7F);
x += 1;
}
i += 1;
} else if (data[i] < 32 || data[i] >= 127) {
termpaint_surface_write_with_colors(surface, x, y, "\\x", rgb_white, rgb_red7F);
x += 2;
char buf[3];
sprintf(buf, "%02x", (unsigned char)data[i]);
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_red7F);
x += 2;
} else {
char buf[2] = {data[i], 0};
termpaint_surface_write_with_colors(surface, x, y, buf, rgb_white, rgb_grey7F);
x += 1;
}
}
}
void render() {
termpaint_surface_clear(surface, rgb_white, rgb_black);
termpaint_surface_write_with_colors(surface, 0, 0, "Input Decoding", rgb_white, rgb_black);
termpaint_surface_write_with_colors(surface, 5, 23, "m for menu", rgb_white, rgb_black);
termpaint_surface_write_with_colors(surface, 20, 0, terminal_info.data(), rgb_greyCC, rgb_black);
if (peek_buffer.length()) {
termpaint_surface_write_with_colors(surface, 0, 23, "unmatched:", rgb_redFF, rgb_black);
display_esc(11, 23, peek_buffer);
}
int y = 2;
for (DisplayEvent &event : ring) {
display_esc(5, y, event.raw);
termpaint_surface_write_with_colors(surface, 30, y, event.eventString.data(), rgb_redFF, rgb_black);
++y;
}
if (m_mode) {
y = 10;
termpaint_surface_write_with_colors(surface, 10, y++, "+ Choose: +", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| q: quit |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| 0: mouse off |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| 1: mouse clicks on |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| 2: mouse drag on |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| 3: mouse movements on |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| 4: toggle focus tracking |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| 6: toggle legacy mouse sup |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| p: toggle tagged paste |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| r: toggle tagged paste raw |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| a: toggle APC parsing |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "| x: raw mode switch |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, y++, "+----------------------------+", rgb_black, rgb_greyCC);
}
if (raw_command_mode) {
termpaint_surface_write_with_colors(surface, 10, 10, "+ Sequence to send: +", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, 11, "| ESC |", rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 15, 11, raw_commmand_str.data(), rgb_black, rgb_greyCC);
termpaint_surface_write_with_colors(surface, 10, 12, "+--------------------------------------------+", rgb_black, rgb_greyCC);
}
termpaint_terminal_flush(terminal, false);
}
int main(int argc, char **argv) {
std::string init_str;
bool init_str_set = false;
if (argc >= 3 && argv[1] == std::string("--init")) {
init_str = argv[2];
init_str_set = true;
}
termpaint_integration *integration = termpaintx_full_integration(init_str_set ? init_str.data() : "+kbdsigint +kbdsigtstp");
if (!integration) {
puts("Could not init!");
return 1;
}
terminal = termpaint_terminal_new(integration);
termpaintx_full_integration_set_terminal(integration, terminal);
surface = termpaint_terminal_get_surface(terminal);
termpaint_terminal_set_raw_input_filter_cb(terminal, raw_filter, 0);
termpaint_terminal_set_event_cb(terminal, event_handler, 0);
termpaint_terminal_auto_detect(terminal);
termpaintx_full_integration_wait_for_ready_with_message(integration, 10000,
"Terminal auto detection is taking unusually long, press space to abort.");
termpaintx_full_integration_apply_input_quirks(integration);
int width, height;
termpaintx_full_integration_terminal_size(integration, &width, &height);
termpaint_terminal_setup_fullscreen(terminal, width, height, init_str_set ? init_str.data() : "+kbdsig");
termpaintx_full_integration_ttyrescue_start(integration);
if (termpaint_terminal_auto_detect_state(terminal) == termpaint_auto_detect_done) {
char buff[100];
termpaint_terminal_auto_detect_result_text(terminal, buff, sizeof (buff));
terminal_info = std::string(buff);
}
render();
while (!quit) {
if (!termpaintx_full_integration_do_iteration(integration)) {
// some kind of error
break;
}
peek_buffer = std::string(termpaint_terminal_peek_input_buffer(terminal), termpaint_terminal_peek_input_buffer_length(terminal));
while (ring.size() > 18) {
ring.erase(ring.begin());
}
render();
}
termpaint_terminal_free_with_restore(terminal);
return 0;
}
termpaint-0.3.1/meson.build 0000664 0000000 0000000 00000026040 14773035472 0015676 0 ustar 00root root 0000000 0000000 # SPDX-License-Identifier: BSL-1.0
project('termpaint', ['c', 'cpp'],
default_options : ['buildtype=debugoptimized', 'cpp_std=c++14', 'c_std=gnu11'],
version: '0.3.1')
if meson.get_compiler('cpp').get_id() == 'gcc' or meson.get_compiler('cpp').get_id() == 'clang'
add_project_arguments('-fvisibility=hidden', '-DTERMPAINT_EXPORT_SYMBOLS', language: 'c')
add_project_arguments('-fvisibility=hidden', '-fvisibility-inlines-hidden', '-DTERMPAINT_EXPORT_SYMBOLS', language: 'cpp')
endif
cc = meson.get_compiler('c')
add_project_arguments(cc.get_supported_arguments('-Wall', '-Wextra',
'-Werror=strict-prototypes', '-Werror=incompatible-pointer-types',
'-Werror=implicit-int', '-Werror=discarded-qualifiers',
'-Wno-string-plus-int'), language: 'c')
add_project_arguments('-Werror=return-type', '-Werror=implicit-function-declaration', '-Werror=int-conversion', '-Werror=old-style-definition', language: 'c')
add_project_arguments('-Wall', '-Wextra', language: 'cpp')
add_project_arguments('-Werror=return-type', language: 'cpp')
if get_option('valgrind-compat')
add_project_arguments('-DTERMPAINTP_VALGRIND', language : 'c')
endif
lib_rt = cc.find_library('rt', required : false) # clock_gettime
silence_warnings = [
'-Wno-padded'
]
main_lib_cargs = []
###### blob ttyrescue
# This option should only default to true on linux (or other supported platforms). But meson
# does not really allow doing that in a reasonable way. So just ignore it on other platforms.
if get_option('ttyrescue-fexec-blob') and host_machine.system() == 'linux'
ttyrescue_fexec_blob_type = get_option('ttyrescue-fexec-blob-type')
if ttyrescue_fexec_blob_type == 'default'
if (host_machine.cpu_family() == 'ppc64' or host_machine.cpu_family() == 's390x'
or host_machine.cpu_family() == 'aarch64')
# the vendored version of linux-syscall-support is known not to work on these architectures
ttyrescue_fexec_blob_type = 'musl-gcc'
else
ttyrescue_fexec_blob_type = 'lss'
endif
endif
if ttyrescue_fexec_blob_type == 'lss'
ttyrescue_blob_exe = executable('ttyrescue_nolibc', 'ttyrescue_nolibc.c',
c_args: ['-fno-asynchronous-unwind-tables', '-fno-ident', '-ffreestanding', '-nostdlib', '-static', '-Os',
'-fvisibility=hidden', '-std=gnu11'],
link_args: ['-fno-asynchronous-unwind-tables', '-fno-ident', '-nostdlib', '-static', '-Os',
'-fvisibility=hidden', '-std=gnu11'])
elif ttyrescue_fexec_blob_type == 'musl-gcc'
# In the future this should be made cross compilation compatible
ttyrescue_blob_exe = custom_target('ttyrescue_blob',
input: 'ttyrescue_mini.c',
output: 'ttyrescue_musl',
command: [find_program('musl-gcc'), '-static', '-no-pie', '-Wl,-znoseparate-code,-z,norelro',
'-fno-asynchronous-unwind-tables', '-fno-ident', '-Os', '-fvisibility=hidden', '-std=gnu11',
'@INPUT@', '-o', '@OUTPUT@'])
endif
ttyrescue_blob_stripped = custom_target('ttyrescue_blob_stripped',
input: ttyrescue_blob_exe,
output: 'ttyrescue_blob_stripped',
command: [find_program('strip'), '--strip-all', '--remove-section=.comment',
'--remove-section=.note', '--remove-section=.eh_frame_hdr',
'--remove-section=.eh_frame', '--remove-section=.note.gnu.gold-version',
'--remove-section=.note.gnu.build-id',
'@INPUT@', '-o', '@OUTPUT@'])
ttyrescue_blob_inc = custom_target('ttyrescue_blob_inc',
input: ttyrescue_blob_stripped,
output: ['ttyrescue_blob.inc'],
command: [find_program('./filetoinc.py'), 'ttyrescue_blob', '@INPUT@', '@OUTPUT0@'])
main_lib_cargs += '-DTERMPAINT_RESCUE_FEXEC'
else
ttyrescue_blob_inc = []
endif
###### /blob ttyrescue
if get_option('errorlog')
debugwin_inc = custom_target('debugwin_inc', output: ['debugwin.py.inc'],
command: [find_program('./filetoinc.py'), 'debugwin', files('debugwin.py'), '@OUTPUT0@'])
main_lib_cargs += '-DUSE_TK_DEBUGLOG'
else
debugwin_inc = []
endif
main_vscript = 'termpaint.symver'
if host_machine.system() == 'linux'
# for now, only do this on linux, expand supported platforms as needed
main_ld_vscript = '-Wl,--version-script,@0@/@1@'.format(meson.current_source_dir(), main_vscript)
else
main_ld_vscript = []
endif
#ide:editable-filelist
main_lib_files = [
'termpaint.c',
'termpaint_event.c',
'termpaint_input.c',
'termpaintx.c',
'termpaintx_ttyrescue.c',
'ttyrescue.c',
debugwin_inc,
ttyrescue_blob_inc
]
main_lib_cargs += '-DTERMPAINT_RESCUE_EMBEDDED'
main_lib_cargs += '-DTERMPAINT_RESCUE_PATH="@0@"'.format(get_option('ttyrescue-path'))
main_lib = library('termpaint', main_lib_files,
dependencies: lib_rt,
c_args: main_lib_cargs,
soversion: '0a',
darwin_versions: ['1', '1'],
link_args : main_ld_vscript,
link_depends : main_vscript,
install: true)
main_lib_installed_headers = [
'termpaint.h',
'termpaint_event.h',
'termpaint_input.h',
'termpaintx.h',
'termpaintx_ttyrescue.h',
]
install_headers(main_lib_installed_headers)
import('pkgconfig').generate(main_lib,
subdirs : '.',
name : 'libtermpaint',
filebase : 'termpaint',
description : 'A terminal cell display and keyboard abstraction library.',
)
termpaint_dep = declare_dependency(
include_directories: include_directories('.'),
link_with: main_lib
)
if meson.version().version_compare('>=0.54')
meson.override_dependency('termpaint', termpaint_dep)
endif
#ide:editable-filelist
ttyrescue_files = [
'ttyrescue.c',
]
ttyrescue_exe_args = {}
if get_option('ttyrescue-install')
ttyrescue_exe_args += {'install': true, 'install_dir': get_option('ttyrescue-path')}
endif
executable('ttyrescue', ttyrescue_files, kwargs: ttyrescue_exe_args)
if cc.has_header('picojson.h', required : get_option('system-picojson'))
picojson_dep = []
else
picojson_dep = declare_dependency(compile_args: ['-DBUNDLED_PICOJSON'])
endif
image_vscript = 'termpaint_image.symver'
if host_machine.system() == 'linux'
image_ld_vscript = '-Wl,--version-script,@0@/@1@'.format(meson.current_source_dir(), image_vscript)
else
image_ld_vscript = []
endif
#ide:editable-filelist
image_lib_files = [
'termpaint_image.cpp',
]
image_lib = library('termpaint_image', image_lib_files, link_with: [main_lib],
dependencies: [picojson_dep],
soversion: '0a',
darwin_versions: ['1', '1'],
link_args : image_ld_vscript,
link_depends : image_vscript,
install: true)
image_lib_installed_headers = [
'termpaint_image.h',
]
install_headers(image_lib_installed_headers)
import('pkgconfig').generate(image_lib,
subdirs : '.',
name : 'libtermpaint_image',
filebase : 'termpaint_image',
description : 'File load and save support for termpaint.',
)
termpaint_image_dep = declare_dependency(
include_directories: include_directories('.'),
link_with: image_lib,
dependencies: termpaint_dep
)
if meson.version().version_compare('>=0.54')
meson.override_dependency('termpaint_image', termpaint_image_dep)
endif
tools_kwargs = {}
if get_option('tools-path') != ''
tools_kwargs += {'install': true, 'install_dir': get_option('tools-path')}
endif
#ide:editable-filelist
inputevents_files = [
'inputevents.cpp',
]
executable('inputevents', inputevents_files, link_with: [main_lib], kwargs: tools_kwargs)
#ide:editable-filelist
attrdemo_files = [
'demo/attrs.c',
]
executable('attrdemo', attrdemo_files, link_with: [main_lib])
#ide:editable-filelist
chardemo_files = [
'demo/chars.c',
]
executable('chardemo', chardemo_files, link_with: [main_lib])
#ide:editable-filelist
shuffledemo_files = [
'demo/shuffle.c',
]
executable('shuffle', shuffledemo_files, link_with: [main_lib])
#ide:editable-filelist
lifedemo_files = [
'demo/life.c',
]
executable('life', lifedemo_files, link_with: [main_lib])
#ide:editable-filelist
textwrapdemo_files = [
'demo/textwrap.c',
]
executable('textwrap', textwrapdemo_files, link_with: [main_lib])
#ide:editable-filelist
detect_files = [
'demo/detect.c',
]
executable('detect', detect_files, link_with: [main_lib], kwargs: tools_kwargs)
#ide:editable-filelist
keyboardcollector_files = [
'tools/keyboardcollector.cpp',
]
executable('keyboardcollector', keyboardcollector_files, link_with: [main_lib], dependencies: [picojson_dep])
if get_option('ssh')
executable('keyboardcollector-ssh', 'tools/keyboardcollector.cpp', 'tools/SshServer.cpp',
cpp_args: ['-DUSE_SSH'],
link_with: [main_lib],
dependencies: dependency('libssh'))
endif
docopt_dep = dependency('docopt', required : get_option('system-docopt'))
if not docopt_dep.found()
docopt_lib = static_library('libdocopt', 'third-party/docopt/docopt.cpp', cpp_args: ['-Wno-unknown-pragmas'])
docopt_dep = declare_dependency(link_with: docopt_lib, compile_args: ['-DBUNDLED_DOCOPT'])
endif
fmt_dep = dependency('fmt', required : get_option('system-fmt'))
if not fmt_dep.found()
fmt_lib = static_library('libfmt', 'third-party/format.cc')
fmt_dep = declare_dependency(link_with: fmt_lib, compile_args: ['-DBUNDLED_FMT'])
endif
executable('mcheck', 'tools/mcheck.cpp', link_with: [main_lib], dependencies: [docopt_dep, fmt_dep, picojson_dep])
executable('termquery', 'termquery.cpp', link_with: [main_lib])
catch2_dep = dependency('catch2', required : get_option('system-catch2'))
if not catch2_dep.found()
catch2_dep = declare_dependency(compile_args: ['-DBUNDLED_CATCH2'])
else
if catch2_dep.version().version_compare('>=3.0')
catch2_dep = [catch2_dep, declare_dependency(compile_args: ['-DCATCH3'])]
endif
endif
testlib = static_library('testlib', 'tests/catch_main.cpp', dependencies: [catch2_dep])
#ide:editable-filelist
test_files = [
'tests/fingerprintingtests.cpp',
'tests/hashtest.cpp',
'tests/input_tests.cpp',
'tests/measurement_tests.cpp',
'tests/surface.cpp',
'tests/terminal_misc.cpp',
'tests/utf8_tests.cpp',
]
testtermpaint = executable('testtermpaint', test_files,
link_with: [main_lib, testlib],
cpp_args: ['-fno-inline', silence_warnings],
dependencies: [catch2_dep, picojson_dep])
testtermpaint_env = environment()
testtermpaint_env.set('TERMPAINT_TEST_DATA', meson.current_source_dir() / ('tests'))
test('testtermpaint', testtermpaint, timeout: 1200, env: testtermpaint_env)
#ide:editable-filelist
test_terminaloutput_files = [
'tests/terminaloutput.cpp',
'tests/terminaloutput_main.cpp',
]
testtermpaint_terminaloutput = executable('testtermpaint_terminaloutput',
test_terminaloutput_files,
link_with: [main_lib],
dependencies: [dependency('threads'), catch2_dep, picojson_dep],
cpp_args: ['-fno-inline', silence_warnings])
# currently can't be run as meson registered test, because it needs a path to a terminal test driver
#test('testtermpaint_terminaloutput', testtermpaint_terminaloutput,
# timeout: 300)
# doc snippets
executable('doc-getting-started', 'doc/getting-started.c', link_with: [main_lib])
executable('doc-sync-event-handling', 'doc/sync-event-handling.c', link_with: [main_lib])
executable('doc-callback-event-handling', 'doc/callback-event-handling.c', link_with: [main_lib])
termpaint-0.3.1/meson_options.txt 0000664 0000000 0000000 00000001462 14773035472 0017172 0 ustar 00root root 0000000 0000000 # SPDX-License-Identifier: BSL-1.0
# termpaintx
option('ttyrescue-path', type : 'string', value : '/usr/libexec')
option('ttyrescue-install', type : 'boolean', value : false)
option('ttyrescue-fexec-blob', type : 'boolean', value : true)
option('ttyrescue-fexec-blob-type', type : 'combo', choices: ['default', 'lss', 'musl-gcc'], value : 'default')
option('tools-path', type : 'string', value : '')
option('valgrind-compat', type : 'boolean', value : true)
option('system-docopt', type : 'feature', value : 'disabled')
option('system-fmt', type : 'feature', value : 'disabled')
option('system-catch2', type : 'feature', value : 'disabled')
option('system-picojson', type : 'feature', value : 'disabled')
option('errorlog', type : 'boolean', value : false)
# samples etc
option('ssh', type : 'boolean', value : false)
termpaint-0.3.1/termpaint.c 0000664 0000000 0000000 00000700723 14773035472 0015712 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#include "termpaint.h"
#include
#include
#include
#include
#include
#include
#include
#include "termpaint_compiler.h"
#include "termpaint_input.h"
#include "termpaint_utf8.h"
#include "termpaint_hash.h"
#include "termpaint_char_width.h"
/* TODO and known problems:
* What about composing code points?
*
*
*/
#ifndef __STDC_VERSION_STDDEF_H__
#ifndef nullptr
#define nullptr ((void*)0)
#endif
#endif
// First cast to void* in order to silence alignment warnings because the containing structure,
// ensures that the offsets work out in a way that alignment is correct.
#define container_of(ptr, type, member) ((type *)(void*)(((char*)(ptr)) - offsetof(type, member)))
#define BUG(x) abort()
typedef unsigned char uchar;
/* Data model
*
* A surface is a 2 dimensional array of cells. A cluster occupies a continuous span of
* 1 to 16 cells in one line.
*
* Each cluster can contain a string of unicode codepoints that the terminal will use
* to form an grapheme. These strings consist of a base character and possible a
* sequence of nonspacing combining marks. These describe the minimal unit the terminal
* will display. If this unit is split or partially erased the whole unit will disappear.
*
* Additionally cluster has display (and/or semantic) attributes. These include foreground
* and background color as well as a variety of decorations. Additionally there is a low
* level extension mechanism to allow adding, as of now, not supported additional attributes
* to the cluster. In the later case the application is responible for not breaking
* rendering with these low level patches.
*
* Data representation
*
* The unicode codepoints for an cluster are either represented as a up to 8 byte utf8
* sequence inline in the cell structure or by an reference to an separate overflow node
* in case they do not fit within that space. These overflow nodes are managed with an
* auxilary (per surface) hash table. Unused entries are expired when the hash table would
* have to grow otherwise.
*
* Attributes consist of the following:
* - bold (yes/no)
* - italic (yes/no)
* - underline (none, single, double, curly) with decoration color (default or 256 color
* or direct color value)
* - blinking (yes/no)
* - overline (yes/no)
* - inverse (yes/no)
* - strikethrough (yes/no)
* - foreground color (default or 16 colors (named or bright named)
* or 256 color or direct color)
* - background color (same options as foreground color)
* - patch (an beginning and ending string of control sequences; 0 no patch else index + 1 of patches array in surface)
*
* text_len == 0 && text_overflow == nullptr -> same as ' '
* text_len == 0 && text_overflow == WIDE_RIGHT_PADDING -> character hidden by multi cell cluster
* text_len == 1 && text[0] == '\x01', only in cells_last_flush => cell was hidden, will need repaint if start of char.
*
* Additional invariants:
* - The colors and flags (except CELL_SOFTWRAP_MARKER) of all cells in a cluster are identical.
*/
struct termpaint_attr_ {
uint32_t fg_color;
uint32_t bg_color;
uint32_t deco_color;
uint16_t flags;
// If no patch is active all these are 0, otherwise both setup and cleanup contain non zero pointers.
bool patch_optimize;
unsigned char* patch_setup;
unsigned char* patch_cleanup;
};
#define CELL_ATTR_BOLD (1 << 0)
#define CELL_ATTR_ITALIC (1 << 1)
#define CELL_ATTR_UNDERLINE_MASK (3 << 2)
#define CELL_ATTR_UNDERLINE_SINGLE (1 << 2)
#define CELL_ATTR_UNDERLINE_DOUBLE (2 << 2)
#define CELL_ATTR_UNDERLINE_CURLY (3 << 2)
#define CELL_ATTR_BLINK (1 << 4)
#define CELL_ATTR_OVERLINE (1 << 5)
#define CELL_ATTR_INVERSE (1 << 6)
#define CELL_ATTR_STRIKE (1 << 7)
#define CELL_ATTR_DECO_MASK CELL_ATTR_UNDERLINE_MASK
#define CELL_SOFTWRAP_MARKER (1 << 15)
#define CELL_ATTR_MASK ((uint16_t)(~CELL_SOFTWRAP_MARKER))
#define TERMPAINT_STYLE_PASSTHROUGH (TERMPAINT_STYLE_BOLD | TERMPAINT_STYLE_ITALIC | TERMPAINT_STYLE_BLINK \
| TERMPAINT_STYLE_OVERLINE | TERMPAINT_STYLE_INVERSE | TERMPAINT_STYLE_STRIKE)
#define WIDE_RIGHT_PADDING ((termpaint_hash_item*)-1)
typedef struct cell_ {
uint32_t fg_color;
uint32_t bg_color;
uint32_t deco_color;
uint16_t flags; // bold, italic, underline[2], blinking, overline, inverse, strikethrough. softwrap marker
uint8_t attr_patch_idx;
uint8_t cluster_expansion : 4;
uint8_t text_len : 4; // == 0 -> text_overflow is active or WIDE_RIGHT_PADDING.
union {
termpaint_hash_item* text_overflow;
unsigned char text[8];
};
} cell;
_Static_assert(sizeof(void*) > 8 || sizeof(cell) == 24, "bad cell size");
typedef struct termpaintp_patch_ {
bool optimize;
uint32_t setup_hash;
unsigned char *setup;
uint32_t cleanup_hash;
unsigned char *cleanup;
bool unused;
} termpaintp_patch;
struct termpaint_surface_ {
termpaint_terminal *terminal;
bool primary;
cell* cells;
cell* cells_last_flush;
unsigned cells_allocated;
int width;
int height;
termpaint_hash overflow_text;
termpaintp_patch *patches;
};
typedef enum auto_detect_state_ {
AD_NONE,
AD_INITIAL,
AD_FINISHED,
// does \033[5n work?
AD_BASICCOMPAT,
// Basics: cursor position, secondary id, device ready?
AD_BASIC_REQ,
AD_BASIC_CURPOS_RECVED,
AD_BASIC_REQ_FAILED_CURPOS_RECVED,
AD_BASIC_CURPOS_RECVED_NO_SEC_DEV_ATTRIB,
AD_BASIC_NO_SEC_DEV_ATTRIB_MISPARSING,
AD_BASIC_SEC_DEV_ATTRIB_RECVED,
AD_BASIC_SEC_DEV_ATTRIB_RECVED_CONSUME_CURPOS,
// urxvt palette size detection
AD_URXVT_88_256_REQ,
// finger print 1: Test for 'private' cursor position, xterm secondary id quirk, vte CSI 1x quirk
AD_FP1_REQ,
AD_FP1_REQ_TERMID_RECVED,
AD_FP1_REQ_TERMID_RECVED_SEC_DEV_ATTRIB_RECVED,
AD_FP1_SEC_DEV_ATTRIB_RECVED,
AD_FP1_SEC_DEV_ATTRIB_QMCURSOR_POS_RECVED,
AD_FP1_QMCURSOR_POS_RECVED,
AD_FP1_3RD_DEV_ATTRIB_ALIASED_TO_PRI,
AD_FP1_CLEANUP_AFTER_SYNC,
AD_FP1_CLEANUP,
AD_EXPECT_SYNC_TO_FINISH,
AD_WAIT_FOR_SYNC_TO_FINISH,
// finger print 2: Test for konsole repeated secondary id quirk (2 ansers), Test for VTE secondary id quirk (no answer)
AD_FP2_REQ,
AD_FP2_CURSOR_DONE,
AD_FP2_SEC_DEV_ATTRIB_RECVED1,
AD_FP2_SEC_DEV_ATTRIB_RECVED2,
// post
AD_WAIT_FOR_SYNC_TO_SELF_REPORTING,
AD_EXPECT_SYNC_TO_SELF_REPORTING,
AD_SELF_REPORTING,
// sub routine
AD_GLITCH_PATCHING,
// hacks
AD_HTERM_RECOVERY1,
AD_HTERM_RECOVERY2
} auto_detect_state;
typedef enum terminal_type_enum_ {
TT_INCOMPATIBLE, // does not respond to ESC 5n, or similar deal breakers
TT_TOODUMB,
TT_MISPARSING, // valid sequences (bare or >) leave visual traces
TT_UNKNOWN,
TT_BASE,
TT_XTERM,
TT_URXVT,
TT_MLTERM,
TT_KONSOLE,
TT_VTE,
TT_SCREEN,
TT_TMUX,
TT_LINUXVC,
TT_MACOS,
TT_ITERM2,
TT_TERMINOLOGY,
TT_KITTY,
TT_MINTTY,
TT_MSFT_TERMINAL,
TT_FULL,
} terminal_type_enum;
enum termpaint_color_entry_save_state_t {
termpaint_save_state_new_entry = 0, // set via calloc
termpaint_save_state_ready,
termpaint_save_state_save_requested
};
typedef struct termpaint_str_ {
unsigned len;
unsigned alloc;
unsigned char *data;
} termpaint_str;
typedef struct termpaint_color_entry_ {
termpaint_hash_item base;
termpaint_str restore;
termpaint_str requested;
bool dirty;
enum termpaint_color_entry_save_state_t save_state;
struct termpaint_color_entry_ *next_dirty;
} termpaint_color_entry;
typedef struct termpaint_unpause_snippet_ {
termpaint_hash_item base;
termpaint_str sequences;
} termpaint_unpause_snippet;
typedef struct termpaint_integration_private_ {
void (*free)(struct termpaint_integration_ *integration);
void (*write)(struct termpaint_integration_ *integration, const char *data, int length);
void (*flush)(struct termpaint_integration_ *integration);
_Bool (*is_bad)(struct termpaint_integration_ *integration);
void (*request_callback)(struct termpaint_integration_ *integration);
void (*awaiting_response)(struct termpaint_integration_ *integration);
void (*restore_sequence_updated)(struct termpaint_integration_ *integration, const char *data, int length);
void (*logging_func)(struct termpaint_integration_ *integration, const char *data, int length);
} termpaint_integration_private;
#define NUM_CAPABILITIES 16
#define SETUP_STATE_FULLSCREEN 1
#define SETUP_STATE_INLINE 2
typedef struct termpaint_terminal_ {
termpaint_integration *integration;
termpaint_integration_private *integration_vtbl;
termpaint_surface primary;
termpaint_input *input;
bool force_full_repaint;
bool data_pending_after_input_received : 1;
bool request_repaint : 1;
termpaint_str auto_detect_sec_device_attributes;
// line of the terminal cursor relativ to the top of the inline display in the terminal; -1 if not in inline mode.
int inline_current_terminal_cursor_line;
// number of rows currently shown in terminal in inline mode; 0 if no lines are currently painted in inline mode.
int last_inline_height;
int setup_state;
int terminal_type;
const termpaintp_width *char_width_table;
int terminal_version;
int terminal_type_confidence;
termpaint_str terminal_self_reported_name_version;
void (*event_cb)(void *, termpaint_event *);
void *event_user_data;
bool (*raw_input_filter_cb)(void *user_data, const char *data, unsigned length, bool overflow);
void *raw_input_filter_user_data;
int initial_cursor_x;
int initial_cursor_y;
bool cursor_visible;
int cursor_x;
int cursor_y;
int cursor_style;
bool cursor_blink;
unsigned did_terminal_push_title : 1;
unsigned did_terminal_add_mouse_to_restore : 1;
unsigned did_terminal_enable_mouse : 1;
unsigned did_terminal_add_focusreporting_to_restore : 1;
unsigned did_terminal_add_bracketedpaste_to_restore : 1;
unsigned did_terminal_disable_wrap : 1;
unsigned altscreen_active : 1;
unsigned cache_should_use_truecolor : 1;
termpaint_str unpause_basic_setup;
termpaint_hash unpause_snippets;
bool glitch_on_oom;
unsigned log_mask;
int cursor_prev_data; // -1 -> no touched yet, restore not setup, -2 -> force resend sequence (e.g. atfer unpause)
termpaint_hash colors;
termpaint_color_entry *colors_dirty;
termpaint_str restore_seq_partial;
termpaint_str restore_seq_cached;
auto_detect_state ad_state;
// additional auto detect state machine temporary space
int glitch_cursor_x;
int glitch_cursor_y;
bool seen_dec_terminal_param;
auto_detect_state glitch_patching_next_state;
//
bool capabilities[NUM_CAPABILITIES];
int max_csi_parameters;
} termpaint_terminal;
typedef enum termpaint_text_measurement_state_ {
TM_INITIAL,
TM_IN_CLUSTER
} termpaint_text_measurement_state;
typedef enum termpaint_text_measurement_decoder_state_ {
TMD_INITIAL,
TMD_PARTIAL_UTF16,
TMD_PARTIAL_UTF8
} termpaint_text_measurement_decoder_state;
struct termpaint_text_measurement_ {
termpaint_terminal *terminal;
int pending_codepoints;
int pending_clusters;
int pending_width;
int pending_ref;
int last_codepoints;
int last_clusters;
int last_width;
int last_ref;
termpaint_text_measurement_state state;
int limit_codepoints;
int limit_clusters;
int limit_width;
int limit_ref;
// utf decoder state
termpaint_text_measurement_decoder_state decoder_state;
uint16_t utf_16_high;
uint8_t utf8_size;
uint8_t utf8_available;
uint8_t utf8_units[6];
};
static size_t ustrlen (const uchar *s) {
return strlen((const char*)s);
}
static unsigned char *ustrdup (const uchar *s) {
return (unsigned char*)strdup((const char*)s);
}
static int ustrcmp (const uchar *s1, const uchar *s2) {
return strcmp((const char*)s1, (const char*)s2);
}
static bool ustr_eq (const uchar *s1, const uchar *s2) {
return strcmp((const char*)s1, (const char*)s2) == 0;
}
static void int_debuglog_puts(termpaint_terminal *term, const char *str);
static void int_debuglog_printf(termpaint_terminal *term, const char *fmt, ...) ATTRIBUTE_PRINTF;
static void termpaintp_oom_log_only(termpaint_terminal *term) {
int_debuglog_puts(term, "failed to allocate memory, output will be incomplete\n");
}
static void termpaintp_oom(termpaint_terminal *term) {
int_debuglog_puts(term, "failed to allocate memory, aborting\n");
abort();
}
static void termpaintp_oom_int(termpaint_integration *integration) {
const char *msg = "failed to allocate memory, aborting\n";
if (integration->p->logging_func) {
integration->p->logging_func(integration, msg, strlen(msg));
}
abort();
}
static void termpaintp_oom_nolog(void) {
abort();
}
static int replace_unusable_codepoints(int codepoint) {
if (codepoint < 32
|| (codepoint >= 0x7f && codepoint < 0xa0)) {
return ' ';
} else if (codepoint == 0xad) { // soft hyphen
// Some implementations see this as spacing others as non spacing, make sure we get something spacing.
return '-';
} else {
return codepoint;
}
}
static bool termpaintp_string_prefix(const unsigned char * prefix, const unsigned char *s, int len) {
const int plen = ustrlen(prefix);
if (plen <= len) {
return memcmp(prefix, s, plen) == 0;
}
return false;
}
static bool termpaintp_char_ascii_num(char c) {
return '0' <= c && c <= '9';
}
static char termpaintp_char_ascii_to_lower(char c) {
if ('A' <= c && c <= 'Z') {
return c | 0x20;
}
return c;
}
static bool termpaintp_mem_ascii_case_insensitive_equals(const char *a, const char *b, size_t len) {
for (size_t i = 0; i < len; i++) {
char ch1 = termpaintp_char_ascii_to_lower(a[i]);
char ch2 = termpaintp_char_ascii_to_lower(b[i]);
if (ch1 == ch2) continue;
return false;
}
return true;
}
static void termpaintp_str_realloc(termpaint_str *tps, unsigned len);
static void termpaintp_prepend_str(termpaint_str *tps, const unsigned char* src) {
size_t old_len = tps->len;
size_t src_len = ustrlen(src);
termpaintp_str_realloc(tps, old_len + src_len);
if (old_len) {
memmove(tps->data + src_len, tps->data, old_len);
}
tps->data[src_len + old_len] = 0;
memcpy(tps->data, src, src_len);
tps->len = src_len + old_len;
}
static bool termpaintp_str_ends_with(const unsigned char* str, const unsigned char* postfix) {
size_t str_len = ustrlen(str);
size_t postfix_len = ustrlen(postfix);
if (str_len < postfix_len) return false;
return memcmp(str + str_len - postfix_len, postfix, postfix_len) == 0;
}
static bool termpaintp_str_preallocate(termpaint_str *tps, unsigned len) {
if (tps->len || tps->data) {
BUG("preallocation only valid on unused tps");
}
tps->alloc = len + 1;
tps->data = malloc(tps->alloc);
if (!tps->data) {
tps->alloc = 0;
return false;
}
tps->data[0] = 0;
return true;
}
// make sure tps has len capacity. contents of *data is undefined after this
static void termpaintp_str_w_e(termpaint_str *tps, unsigned len) {
if (tps->alloc <= len) {
free(tps->data);
tps->alloc = len + 1;
tps->data = malloc(tps->alloc);
if (!tps->data) {
termpaintp_oom_nolog();
}
}
}
static bool termpaintp_str_w_e_mustcheck(termpaint_str *tps, unsigned len) {
if (tps->alloc <= len) {
unsigned char* data_new = malloc(len + 1);
if (!data_new) {
return false;
}
free(tps->data);
tps->alloc = len + 1;
tps->data = data_new;
}
return true;
}
static void termpaintp_str_realloc(termpaint_str *tps, unsigned len) {
if (tps->alloc <= len) {
tps->alloc = len + 1;
tps->data = realloc(tps->data, tps->alloc);
if (!tps->data) {
termpaintp_oom_nolog();
}
}
}
static void termpaintp_str_assign_n(termpaint_str *tps, const char *s, unsigned len) {
termpaintp_str_w_e(tps, len);
memcpy(tps->data, s, len);
tps->data[len] = 0;
tps->len = len;
}
static void termpaintp_str_assign(termpaint_str *tps, const char *s) {
unsigned len = (unsigned)strlen(s);
termpaintp_str_w_e(tps, len);
memcpy(tps->data, s, len + 1);
tps->len = len;
}
static bool termpaintp_str_assign_mustcheck(termpaint_str *tps, const char *s) {
unsigned len = (unsigned)strlen(s);
if (!termpaintp_str_w_e_mustcheck(tps, len)) {
return false;
}
memcpy(tps->data, s, len + 1);
tps->len = len;
return true;
}
static void termpaintp_str_destroy(termpaint_str *tps) {
free(tps->data);
tps->data = nullptr;
tps->len = 0;
tps->alloc = 0;
}
static void termpaintp_str_append_n(termpaint_str *tps, const char *s, unsigned len) {
termpaintp_str_realloc(tps, tps->len + len);
memcpy(tps->data + tps->len, s, len);
tps->len = tps->len + len;
tps->data[tps->len] = 0;
}
static void termpaintp_str_append(termpaint_str *tps, const char *s) {
termpaintp_str_append_n(tps, s, (unsigned)strlen(s));
}
static void termpaintp_str_append_printable_n(termpaint_str *tps, const char *str, int len) {
int input_bytes_used = 0;
termpaintp_str_realloc(tps, tps->len + (unsigned)len);
while (input_bytes_used < len) {
int size = termpaintp_utf8_len((unsigned char)str[input_bytes_used]);
// check termpaintp_utf8_decode_from_utf8 precondition
if (input_bytes_used + size > len) {
// bogus, bail
return;
}
if (termpaintp_check_valid_sequence((const unsigned char*)str + input_bytes_used, size)) {
int codepoint = termpaintp_utf8_decode_from_utf8((const unsigned char*)str + input_bytes_used, size);
int new_codepoint = replace_unusable_codepoints(codepoint);
if (codepoint == new_codepoint) {
termpaintp_str_append_n(tps, str + input_bytes_used, size);
} else {
if (new_codepoint < 128) {
char ch;
ch = new_codepoint;
termpaintp_str_append_n(tps, &ch, 1);
}
}
}
input_bytes_used += size;
}
}
#define TERMPAINTP_STR_STORE_S(var, value) const char *var = (value)
#define TERMPAINTP_STR_SIZER_S(value) strlen(value)
#define TERMPAINTP_STR_APPEND_S(tps, value, len) termpaintp_str_append_n((tps), (value), (len))
#define TERMPAINTP_STR_STORE_F(var, value) const char *var = (value)
#define TERMPAINTP_STR_SIZER_F(value) strlen(value)
#define TERMPAINTP_STR_APPEND_F(tps, value, len) termpaintp_str_append_printable_n((tps), (value), (len))
#define TERMPAINT_STR_ASSIGN3_MUSTCHECK(tps, type1, value1, type2, value2, type3, value3) \
do { \
termpaint_str* tps_TMP_tps = (tps); \
TERMPAINTP_STR_STORE_##type1(tps_TMP_1, (value1)); \
TERMPAINTP_STR_STORE_##type2(tps_TMP_2, (value2)); \
TERMPAINTP_STR_STORE_##type3(tps_TMP_3, (value3)); \
unsigned tps_TMP_len1 = (unsigned)TERMPAINTP_STR_SIZER_##type1(tps_TMP_1); \
unsigned tps_TMP_len2 = (unsigned)TERMPAINTP_STR_SIZER_##type2(tps_TMP_2); \
unsigned tps_TMP_len3 = (unsigned)TERMPAINTP_STR_SIZER_##type3(tps_TMP_3); \
tps_TMP_tps->len = 0; \
if (termpaintp_str_w_e_mustcheck(tps_TMP_tps, tps_TMP_len1 + tps_TMP_len2 + tps_TMP_len3)) { \
TERMPAINTP_STR_APPEND_##type1(tps_TMP_tps, tps_TMP_1, (tps_TMP_len1)); \
TERMPAINTP_STR_APPEND_##type2(tps_TMP_tps, tps_TMP_2, (tps_TMP_len2)); \
TERMPAINTP_STR_APPEND_##type3(tps_TMP_tps, tps_TMP_3, (tps_TMP_len3)); \
} \
} while (0) \
/* end */
bool termpaint_integration_init_mustcheck(termpaint_integration *integration,
void (*free)(termpaint_integration *integration),
void (*write)(termpaint_integration *integration, const char *data, int length),
void (*flush)(termpaint_integration *integration)) {
integration->p = calloc(1, sizeof(termpaint_integration_private));
if (!integration->p) {
return false;
}
integration->p->free = free;
integration->p->write = write;
integration->p->flush = flush;
return true;
}
_tERMPAINT_PUBLIC void termpaint_integration_init(termpaint_integration *integration,
void (*free)(termpaint_integration *integration),
void (*write)(termpaint_integration *integration, const char *data, int length),
void (*flush)(termpaint_integration *integration)) {
if (!termpaint_integration_init_mustcheck(integration, free, write, flush)) {
termpaintp_oom_nolog();
}
}
_tERMPAINT_PUBLIC void termpaint_integration_set_is_bad(termpaint_integration *integration, _Bool (*is_bad)(termpaint_integration *integration)) {
integration->p->is_bad = is_bad;
}
_tERMPAINT_PUBLIC void termpaint_integration_set_request_callback(termpaint_integration *integration, void (*request_callback)(termpaint_integration *integration)) {
integration->p->request_callback = request_callback;
}
_tERMPAINT_PUBLIC void termpaint_integration_set_awaiting_response(termpaint_integration *integration, void (*awaiting_response)(termpaint_integration *integration)) {
integration->p->awaiting_response = awaiting_response;
}
_tERMPAINT_PUBLIC void termpaint_integration_set_restore_sequence_updated(termpaint_integration *integration, void (*restore_sequence_updated)(termpaint_integration *integration, const char *data, int length)) {
integration->p->restore_sequence_updated = restore_sequence_updated;
}
_tERMPAINT_PUBLIC void termpaint_integration_set_logging_func(termpaint_integration *integration, void (*logging_func)(termpaint_integration *integration, const char *data, int length)) {
integration->p->logging_func = logging_func;
}
void termpaint_integration_deinit(termpaint_integration *integration) {
free(integration->p);
integration->p = nullptr;
}
static void termpaintp_collapse(termpaint_surface *surface) {
surface->width = 0;
surface->height = 0;
surface->cells_allocated = 0;
surface->cells = nullptr;
surface->cells_last_flush = nullptr;
}
static bool termpaintp_resize_mustcheck(termpaint_surface *surface, int width, int height) {
// TODO move contents along?
surface->width = width;
surface->height = height;
_Static_assert(sizeof(int) <= sizeof(size_t), "int smaller than size_t");
int bytes;
int cell_count;
if (
(width < 0) || (height < 0)
|| termpaint_smul_overflow(width, height, &cell_count)
|| termpaint_smul_overflow(cell_count, sizeof(cell), &bytes)) {
// collapse and bail
int_debuglog_printf(surface->terminal, "surface resize: Invalid size %dx%d, collapsing surface.", width, height);
free(surface->cells);
free(surface->cells_last_flush);
termpaintp_collapse(surface);
return true; // This is debatable, but the previous code did allow this and there are tests for this.
}
surface->cells_allocated = cell_count;
free(surface->cells);
free(surface->cells_last_flush);
surface->cells_last_flush = nullptr;
surface->cells = calloc(1, bytes);
if (!surface->cells) {
termpaintp_collapse(surface);
return false;
}
if (surface->primary) {
surface->terminal->force_full_repaint = true;
surface->cells_last_flush = calloc(1, surface->cells_allocated * sizeof(cell));
if (!surface->cells_last_flush) {
free(surface->cells);
termpaintp_collapse(surface);
return false;
}
}
return true;
}
static inline cell* termpaintp_getcell(const termpaint_surface *surface, int x, int y) {
unsigned index = y*surface->width + x;
if (x >= 0 && y >= 0
&& x < surface->width && y < surface->height
&& index < surface->cells_allocated) {
return &surface->cells[index];
} else {
BUG("cell out of range");
}
}
static inline cell* termpaintp_getcell_or_null(const termpaint_surface *surface, int x, int y) {
unsigned index = y*surface->width + x;
if (x >= 0 && y >= 0
&& x < surface->width && y < surface->height) {
if (index < surface->cells_allocated) {
return &surface->cells[index];
} else {
BUG("cell out of range");
}
} else {
return nullptr;
}
}
static void termpaintp_set_overflow_text(termpaint_surface *surface, cell *dst_cell, const unsigned char* data) {
// hash_ensure needs to be done before touching text_len, because it can cause garbage collection which would
// see an inconistant state if text_len is already set to zero.
void* overflow_ptr = termpaintp_hash_ensure(&surface->overflow_text, data);
if (!overflow_ptr) {
if (!surface->terminal->glitch_on_oom) {
termpaintp_oom(surface->terminal);
} else {
termpaintp_oom_log_only(surface->terminal);
dst_cell->text_len = 1;
dst_cell->text[0] = '?';
}
}
dst_cell->text_len = 0;
dst_cell->text_overflow = overflow_ptr;
}
static void termpaintp_surface_destroy(termpaint_surface *surface) {
free(surface->cells);
free(surface->cells_last_flush);
termpaintp_hash_destroy(&surface->overflow_text);
if (surface->patches) {
for (int i = 0; i < 255; ++i) {
free(surface->patches[i].setup);
free(surface->patches[i].cleanup);
}
free(surface->patches);
surface->patches = nullptr;
}
termpaintp_collapse(surface);
}
static uint8_t termpaintp_surface_ensure_patch_idx(termpaint_surface *surface, bool optimize, unsigned char *setup,
unsigned char *cleanup) {
if (!setup || !cleanup) {
return 0;
}
if (!surface->patches) {
surface->patches = calloc(255, sizeof(termpaintp_patch));
if (!surface->patches) {
if (!surface->terminal->glitch_on_oom) {
termpaintp_oom(surface->terminal);
} else {
termpaintp_oom_log_only(surface->terminal);
return 0;
}
}
}
uint32_t setup_hash = termpaintp_hash_fnv1a(setup);
uint32_t cleanup_hash = termpaintp_hash_fnv1a(cleanup);
int free_slot = -1;
for (int i = 0; i < 255; ++i) {
if (!surface->patches[i].setup) {
if (free_slot == -1) {
free_slot = i;
}
continue;
}
if (surface->patches[i].setup_hash == setup_hash
&& surface->patches[i].cleanup_hash == cleanup_hash
&& ustrcmp(setup, surface->patches[i].setup) == 0
&& ustrcmp(cleanup, surface->patches[i].cleanup) == 0) {
return i + 1;
}
}
if (free_slot == -1) {
// try to free unused entries
for (int i = 0; i < 255; ++i) {
surface->patches[i].unused = true;
}
for (int y = 0; y < surface->height; y++) {
for (int x = 0; x < surface->width; x++) {
cell* c = termpaintp_getcell(surface, x, y);
if (c->attr_patch_idx) {
surface->patches[c->attr_patch_idx - 1].unused = false;
}
if (surface->cells_last_flush) {
cell* old_c = &surface->cells_last_flush[y*surface->width+x];
if (old_c->attr_patch_idx) {
surface->patches[old_c->attr_patch_idx - 1].unused = false;
}
}
}
}
for (int i = 0; i < 255; ++i) {
if (surface->patches[i].unused) {
free(surface->patches[i].setup);
free(surface->patches[i].cleanup);
surface->patches[i].setup = nullptr;
surface->patches[i].cleanup = nullptr;
if (free_slot == -1) {
free_slot = i;
}
}
}
}
if (free_slot != -1) {
unsigned char *setup_copy = ustrdup(setup);
unsigned char *cleanup_copy = ustrdup(cleanup);
if (!setup_copy || !cleanup_copy) {
if (!surface->terminal->glitch_on_oom) {
termpaintp_oom(surface->terminal);
} else {
free(setup_copy);
free(cleanup_copy);
termpaintp_oom_log_only(surface->terminal);
return 0;
}
}
surface->patches[free_slot].optimize = optimize;
surface->patches[free_slot].setup_hash = setup_hash;
surface->patches[free_slot].cleanup_hash = cleanup_hash;
surface->patches[free_slot].setup = setup_copy;
surface->patches[free_slot].cleanup = cleanup_copy;
return free_slot + 1;
}
// can't fit anymore, just ignore it.
return 0;
}
void termpaint_surface_write_with_colors(termpaint_surface *surface, int x, int y, const char *string, int fg, int bg) {
termpaint_surface_write_with_colors_clipped(surface, x, y, string, fg, bg, 0, surface->width-1);
}
void termpaint_surface_write_with_len_colors(termpaint_surface *surface, int x, int y, const char *string, int len, int fg, int bg) {
termpaint_surface_write_with_len_colors_clipped(surface, x, y, string, len, fg, bg, 0, surface->width-1);
}
void termpaint_surface_write_with_colors_clipped(termpaint_surface *surface, int x, int y, const char *string, int fg, int bg, int clip_x0, int clip_x1) {
int len = strlen(string);
termpaint_surface_write_with_len_colors_clipped(surface, x, y, string, len, fg, bg, clip_x0, clip_x1);
}
void termpaint_surface_write_with_len_colors_clipped(termpaint_surface *surface, int x, int y, const char *string, int len, int fg, int bg, int clip_x0, int clip_x1) {
termpaint_attr attr;
attr.fg_color = fg;
attr.bg_color = bg;
attr.deco_color = TERMPAINT_DEFAULT_COLOR;
attr.flags = 0;
attr.patch_setup = nullptr;
attr.patch_cleanup = nullptr;
attr.patch_optimize = false;
termpaint_surface_write_with_len_attr_clipped(surface, x, y, string, len, &attr, clip_x0, clip_x1);
}
void termpaint_surface_write_with_attr(termpaint_surface *surface, int x, int y, const char *string, const termpaint_attr *attr) {
termpaint_surface_write_with_attr_clipped(surface, x, y, string, attr, 0, surface->width-1);
}
void termpaint_surface_write_with_len_attr(termpaint_surface *surface, int x, int y, const char *string, int len, const termpaint_attr *attr) {
termpaint_surface_write_with_len_attr_clipped(surface, x, y, string, len, attr, 0, surface->width-1);
}
// This ensures that cells [x, x + cluster_width) have cluster_expansion = 0
static void termpaintp_surface_vanish_char(termpaint_surface *surface, int x, int y, int cluster_width) {
// narrow contract, x + cluster_width <= width
cell *cell = termpaintp_getcell(surface, x, y);
int rightmost_vanished = x;
if (cell->text_len == 0 && cell->text_overflow == WIDE_RIGHT_PADDING) {
int i = x;
while (cell->text_len == 0 && cell->text_overflow == WIDE_RIGHT_PADDING) {
cell->text_len = 1;
cell->text[0] = ' ';
rightmost_vanished = i;
// cell->cluster_expansion == 0 already because padding cell
if (i + 1 == surface->width) {
break;
}
++i;
cell = termpaintp_getcell(surface, i, y);
}
i = x - 1;
do {
cell = termpaintp_getcell(surface, i, y);
cell->text_len = 1;
cell->text[0] = ' ';
// cell->cluster_expansion == 0 already unless this is the last iteration, see fixup below
--i;
} while (cell->cluster_expansion == 0);
cell->cluster_expansion = 0;
}
for (int i = rightmost_vanished; i <= x + cluster_width - 1; i++) {
cell = termpaintp_getcell(surface, i, y);
int expansion = cell->cluster_expansion;
int j = 0;
while (1) {
cell->cluster_expansion = 0;
cell->text_len = 1;
cell->text[0] = ' ';
++j;
if (j > expansion) {
break;
}
cell = termpaintp_getcell(surface, i + j, y);
}
i += expansion;
}
}
static void termpaintp_surface_attr_apply(termpaint_surface *surface, cell *cell, termpaint_attr const *attr) {
cell->fg_color = attr->fg_color;
cell->bg_color = attr->bg_color;
cell->deco_color = attr->deco_color;
cell->flags = attr->flags;
cell->attr_patch_idx = termpaintp_surface_ensure_patch_idx(surface, attr->patch_optimize,
attr->patch_setup, attr->patch_cleanup);
}
void termpaint_surface_write_with_attr_clipped(termpaint_surface *surface, int x, int y, const char *string_s, termpaint_attr const *attr, int clip_x0, int clip_x1) {
int len = strlen(string_s);
termpaint_surface_write_with_len_attr_clipped(surface, x, y, string_s, len, attr, clip_x0, clip_x1);
}
void termpaint_surface_write_with_len_attr_clipped(termpaint_surface *surface, int x, int y, const char *string_s, int len, termpaint_attr const *attr, int clip_x0, int clip_x1) {
const termpaintp_width *char_width_table = surface->terminal->char_width_table;
const unsigned char *string = (const unsigned char *)string_s;
if (y < 0) return;
if (clip_x0 < 0) clip_x0 = 0;
if (clip_x1 >= surface->width) {
clip_x1 = surface->width-1;
}
while (len) {
if (x > clip_x1 || y >= surface->height) {
return;
}
unsigned char cluster_utf8[40];
int cluster_width = 1;
int input_bytes_used = 0;
size_t output_bytes_used = 0;
// ATTENTION keep this in sync with termpaint_text_measurement_feed_codepoint
while (len - input_bytes_used) {
int size = termpaintp_utf8_len(string[input_bytes_used]);
// check termpaintp_utf8_decode_from_utf8 precondition
if (input_bytes_used + size > len) {
// bogus, bail
return;
}
int codepoint;
if (termpaintp_check_valid_sequence(string + input_bytes_used, size)) {
codepoint = termpaintp_utf8_decode_from_utf8(string + input_bytes_used, size);
} else {
// This is bogus usage, but just paper over it
codepoint = 0xFFFD;
}
if (codepoint != '\x7f' || output_bytes_used != 0) {
codepoint = replace_unusable_codepoints(codepoint);
int width = termpaintp_char_width(char_width_table, codepoint);
if (!output_bytes_used) {
if (width == 0) {
// if start is 0 width use U+00a0 as base
output_bytes_used += termpaintp_encode_to_utf8(0xa0, cluster_utf8 + output_bytes_used);
} else {
cluster_width = width;
}
output_bytes_used += termpaintp_encode_to_utf8(codepoint, cluster_utf8 + output_bytes_used);
} else {
if (width > 0) {
// don't increase input_bytes_used here because this codepoint will need to be reprocessed.
break;
}
if (output_bytes_used + 6 < sizeof (cluster_utf8)) {
output_bytes_used += termpaintp_encode_to_utf8(codepoint, cluster_utf8 + output_bytes_used);
} else {
// just ignore further combining codepoints, likely this is way over the limit
// of the terminal anyway
}
}
} else {
output_bytes_used = 0;
input_bytes_used += size;
// do not allow any non spacing modifiers
break;
}
input_bytes_used += size;
}
if (cluster_width == 2 && x + 1 == clip_x0) {
// char is split by clipping boundary. Fill in right half as if the char was split later
cell *c = termpaintp_getcell(surface, x + 1, y);
termpaintp_surface_vanish_char(surface, x + 1, y, cluster_width - 1);
c->cluster_expansion = 0;
termpaintp_surface_attr_apply(surface, c, attr);
c->text[0] = ' ';
c->text_len = 1;
} else if (x + cluster_width - 1 > clip_x1) {
// char is split by clipping boundary. Fill in left half as if the char was split later
cell *c = termpaintp_getcell(surface, x, y);
termpaintp_surface_vanish_char(surface, x, y, cluster_width - 1);
c->cluster_expansion = 0;
termpaintp_surface_attr_apply(surface, c, attr);
c->text[0] = ' ';
c->text_len = 1;
} else if (x >= clip_x0) {
cell *c = termpaintp_getcell(surface, x, y);
termpaintp_surface_vanish_char(surface, x, y, cluster_width);
termpaintp_surface_attr_apply(surface, c, attr);
c->cluster_expansion = cluster_width - 1;
if (output_bytes_used <= 8) {
if (output_bytes_used) {
memcpy(c->text, cluster_utf8, output_bytes_used);
c->text_len = output_bytes_used;
} else {
c->text_len = 0;
c->text_overflow = nullptr;
}
} else {
cluster_utf8[output_bytes_used] = 0;
termpaintp_set_overflow_text(surface, c, cluster_utf8);
}
for (int i = 1; i < cluster_width; i++) {
cell *c = termpaintp_getcell(surface, x + i, y);
termpaintp_surface_attr_apply(surface, c, attr);
c->cluster_expansion = 0;
c->text_len = 0;
c->text_overflow = WIDE_RIGHT_PADDING;
}
}
string += input_bytes_used;
len -= input_bytes_used;
x = x + cluster_width;
}
}
void termpaint_surface_clear_with_attr(termpaint_surface *surface, const termpaint_attr *attr) {
termpaint_surface_clear_rect_with_attr(surface, 0, 0, surface->width, surface->height, attr);
}
void termpaint_surface_clear_with_attr_char(termpaint_surface *surface, const termpaint_attr *attr, int codepoint) {
termpaint_surface_clear_rect_with_attr_char(surface, 0, 0, surface->width, surface->height, attr, codepoint);
}
void termpaint_surface_clear(termpaint_surface *surface, int fg, int bg) {
termpaint_surface_clear_rect(surface, 0, 0, surface->width, surface->height, fg, bg);
}
void termpaint_surface_clear_with_char(termpaint_surface *surface, int fg, int bg, int codepoint) {
termpaint_surface_clear_rect_with_char(surface, 0, 0, surface->width, surface->height, fg, bg, codepoint);
}
static void termpaintp_surface_clear_rect_with_attr_and_string(termpaint_surface *surface, int x, int y,
int width, int height, const termpaint_attr *attr,
const unsigned char* str, unsigned len) {
if (x < 0) {
width += x;
x = 0;
}
if (y < 0) {
height += y;
y = 0;
}
if (width <= 0) return;
if (x >= surface->width) return;
if (y >= surface->height) return;
if (x+width > surface->width) width = surface->width - x;
if (y+height > surface->height) height = surface->height - y;
for (int y1 = y; y1 < y + height; y1++) {
termpaintp_surface_vanish_char(surface, x, y1, 1);
termpaintp_surface_vanish_char(surface, x + width - 1, y1, 1);
for (int x1 = x; x1 < x + width; x1++) {
cell* c = termpaintp_getcell(surface, x1, y1);
c->cluster_expansion = 0;
if (str) {
c->text_len = len;
memcpy(c->text, str, len);
} else {
c->text_len = 0;
c->text_overflow = nullptr;
}
c->bg_color = attr->bg_color;
c->fg_color = attr->fg_color;
c->deco_color = TERMPAINT_DEFAULT_COLOR;
c->flags = attr->flags;
c->attr_patch_idx = 0;
}
}
}
void termpaint_surface_clear_rect_with_attr(termpaint_surface *surface, int x, int y,
int width, int height, const termpaint_attr *attr) {
termpaintp_surface_clear_rect_with_attr_and_string(surface, x, y, width, height, attr, nullptr, 0);
}
void termpaint_surface_clear_rect_with_attr_char(termpaint_surface *surface, int x, int y, int width, int height, const termpaint_attr *attr, int codepoint) {
const termpaintp_width *char_width_table = surface->terminal->char_width_table;
int codepointSanitized = replace_unusable_codepoints(codepoint);
int codepointWidth = termpaintp_char_width(char_width_table, codepoint);
if (codepoint == '\x7f' || codepointWidth != 1) {
termpaint_surface_clear_rect_with_attr(surface, x, y, width, height, attr);
} else {
unsigned char buf[6];
int len = termpaintp_encode_to_utf8(codepointSanitized, buf);
termpaintp_surface_clear_rect_with_attr_and_string(surface, x, y, width, height, attr, buf, len);
}
}
void termpaint_surface_clear_rect(termpaint_surface *surface, int x, int y, int width, int height, int fg, int bg) {
termpaint_attr attr;
attr.fg_color = fg;
attr.bg_color = bg;
attr.deco_color = TERMPAINT_DEFAULT_COLOR;
attr.flags = 0;
attr.patch_setup = nullptr;
attr.patch_cleanup = nullptr;
termpaint_surface_clear_rect_with_attr(surface, x, y, width, height, &attr);
}
void termpaint_surface_clear_rect_with_char(termpaint_surface *surface, int x, int y, int width, int height, int fg, int bg, int codepoint) {
const termpaintp_width *char_width_table = surface->terminal->char_width_table;
int codepointSanitized = replace_unusable_codepoints(codepoint);
int codepointWidth = termpaintp_char_width(char_width_table, codepoint);
if (codepoint == '\x7f' || codepointWidth != 1) {
termpaint_surface_clear_rect(surface, x, y, width, height, fg, bg);
} else {
termpaint_attr attr;
attr.fg_color = fg;
attr.bg_color = bg;
attr.deco_color = TERMPAINT_DEFAULT_COLOR;
attr.flags = 0;
attr.patch_setup = nullptr;
attr.patch_cleanup = nullptr;
termpaint_surface_clear_rect_with_attr_char(surface, x, y, width, height, &attr, codepointSanitized);
}
}
void termpaint_surface_set_fg_color(const termpaint_surface *surface, int x, int y, unsigned fg) {
if (x < 0) return;
if (y < 0) return;
if (x >= surface->width) return;
if (y >= surface->height) return;
cell* c = termpaintp_getcell(surface, x, y);
if (c->text_len == 0 && c->text_overflow == WIDE_RIGHT_PADDING) {
// only the first cell of a multi cell character can be used to change it.
// This prevents duplicate changes with naive adjust each cell code.
return;
}
c->fg_color = fg;
for (int i = 0; i < c->cluster_expansion; i++) {
cell* exp_cell = termpaintp_getcell(surface, x + 1 + i, y);
exp_cell->fg_color = fg;
}
}
void termpaint_surface_set_bg_color(const termpaint_surface *surface, int x, int y, unsigned bg) {
if (x < 0) return;
if (y < 0) return;
if (x >= surface->width) return;
if (y >= surface->height) return;
cell* c = termpaintp_getcell(surface, x, y);
if (c->text_len == 0 && c->text_overflow == WIDE_RIGHT_PADDING) {
// only the first cell of a multi cell character can be used to change it.
// This prevents duplicate changes with naive adjust each cell code.
return;
}
c->bg_color = bg;
for (int i = 0; i < c->cluster_expansion; i++) {
cell* exp_cell = termpaintp_getcell(surface, x + 1 + i, y);
exp_cell->bg_color = bg;
}
}
void termpaint_surface_set_deco_color(const termpaint_surface *surface, int x, int y, unsigned deco_color) {
if (x < 0) return;
if (y < 0) return;
if (x >= surface->width) return;
if (y >= surface->height) return;
cell* c = termpaintp_getcell(surface, x, y);
if (c->text_len == 0 && c->text_overflow == WIDE_RIGHT_PADDING) {
// only the first cell of a multi cell character can be used to change it.
// This prevents duplicate changes with naive adjust each cell code.
return;
}
c->deco_color = deco_color;
for (int i = 0; i < c->cluster_expansion; i++) {
cell* exp_cell = termpaintp_getcell(surface, x + 1 + i, y);
exp_cell->deco_color = deco_color;
}
}
void termpaint_surface_set_softwrap_marker(termpaint_surface *surface, int x, int y, bool state) {
if (x < 0) return;
if (y < 0) return;
if (x >= surface->width) return;
if (y >= surface->height) return;
cell* c = termpaintp_getcell(surface, x, y);
if (c->text_len == 0 && c->text_overflow == WIDE_RIGHT_PADDING) {
// only the first cell of a multi cell character can be used to set the marker
return;
}
if (state) {
c->flags |= CELL_SOFTWRAP_MARKER;
} else {
c->flags &= ~CELL_SOFTWRAP_MARKER;
}
}
bool termpaint_surface_resize_mustcheck(termpaint_surface *surface, int width, int height) {
if (width < 0 || height < 0) {
free(surface->cells);
free(surface->cells_last_flush);
termpaintp_collapse(surface);
} else {
if (!termpaintp_resize_mustcheck(surface, width, height)) {
return false;
}
}
return true;
}
void termpaint_surface_resize(termpaint_surface *surface, int width, int height) {
if (!termpaint_surface_resize_mustcheck(surface, width, height)) {
termpaintp_oom(surface->terminal);
}
}
int termpaint_surface_width(const termpaint_surface *surface) {
return surface->width;
}
int termpaint_surface_height(const termpaint_surface *surface) {
return surface->height;
}
static void termpaintp_surface_gc_mark_cb(termpaint_hash *hash) {
termpaint_surface *surface = container_of(hash, termpaint_surface, overflow_text);
for (int y = 0; y < surface->height; y++) {
for (int x = 0; x < surface->width; x++) {
cell* c = termpaintp_getcell(surface, x, y);
if (c->text_len == 0 && c->text_overflow != nullptr && c->text_overflow != WIDE_RIGHT_PADDING) {
c->text_overflow->unused = false;
}
if (surface->cells_last_flush) {
cell* old_c = &surface->cells_last_flush[y*surface->width+x];
if (old_c->text_len == 0 && old_c->text_overflow != nullptr && c->text_overflow != WIDE_RIGHT_PADDING) {
old_c->text_overflow->unused = false;
}
}
}
}
}
static void termpaintp_surface_init(termpaint_surface *surface, termpaint_terminal *term) {
surface->overflow_text.gc_mark_cb = termpaintp_surface_gc_mark_cb;
surface->overflow_text.item_size = sizeof(termpaint_hash_item);
surface->terminal = term;
}
termpaint_surface *termpaint_terminal_new_surface_or_nullptr(termpaint_terminal *term, int width, int height) {
termpaint_surface *ret = calloc(1, sizeof(termpaint_surface));
if (!ret) {
return nullptr;
}
termpaintp_surface_init(ret, term);
termpaintp_collapse(ret);
if (!termpaintp_resize_mustcheck(ret, width, height)) {
termpaint_surface_free(ret);
return nullptr;
}
return ret;
}
termpaint_surface *termpaint_terminal_new_surface(termpaint_terminal *term, int width, int height) {
termpaint_surface *ret = termpaint_terminal_new_surface_or_nullptr(term, width, height);
if (!ret) {
termpaintp_oom(term);
}
return ret;
}
termpaint_surface *termpaint_surface_new_surface(termpaint_surface *surface, int width, int height) {
return termpaint_terminal_new_surface(surface->terminal, width, height);
}
termpaint_surface *termpaint_surface_new_surface_or_nullptr(termpaint_surface *surface, int width, int height) {
return termpaint_terminal_new_surface_or_nullptr(surface->terminal, width, height);
}
void termpaint_surface_free(termpaint_surface *surface) {
if (!surface) {
return;
}
// guard against freeing the primary surface
if (surface->primary) {
int_debuglog_puts(surface->terminal, "surface_free: Attempt to free primary surface. This is a bug in your application");
return;
}
termpaintp_surface_destroy(surface);
free(surface);
}
static void termpaintp_copy_colors_and_attibutes(termpaint_surface *src_surface, cell *src_cell,
termpaint_surface *dst_surface, cell *dst_cell) {
dst_cell->fg_color = src_cell->fg_color;
dst_cell->bg_color = src_cell->bg_color;
dst_cell->deco_color = src_cell->deco_color;
dst_cell->flags = src_cell->flags;
if (src_cell->attr_patch_idx) {
termpaintp_patch* patch = &src_surface->patches[src_cell->attr_patch_idx - 1];
dst_cell->attr_patch_idx = termpaintp_surface_ensure_patch_idx(dst_surface,
patch->optimize,
patch->setup,
patch->cleanup);
}
}
void termpaint_surface_tint(termpaint_surface *surface,
void (*recolor)(void *user_data, unsigned *fg, unsigned *bg, unsigned *deco),
void *user_data) {
for (int y = 0; y < surface->height; y++) {
for (int x = 0; x < surface->width; x++) {
cell *cell = termpaintp_getcell(surface, x, y);
// Don't give out pointers to internal cell structure contents.
unsigned fg = cell->fg_color;
unsigned bg = cell->bg_color;
unsigned deco = cell->deco_color;
recolor(user_data, &fg, &bg, &deco);
int expansion = cell->cluster_expansion;
// update cluster at once, different colors in one cluster are not allowed
for (int i = 0; i <= expansion; i++) {
cell = termpaintp_getcell(surface, x + i, y);
cell->fg_color = fg;
cell->bg_color = bg;
cell->deco_color = deco;
}
x += expansion;
}
}
}
static void termpaintp_surface_copy_rect_same_surface(termpaint_surface *src_surface, int x, int y, int width, int height,
int dst_x, int dst_y, int tile_left, int tile_right);
void termpaint_surface_copy_rect(termpaint_surface *src_surface, int x, int y, int width, int height,
termpaint_surface *dst_surface, int dst_x, int dst_y, int tile_left, int tile_right) {
if (x < 0) {
width += x;
dst_x -= x;
x = 0;
// also switch left mode to erase
tile_left = TERMPAINT_COPY_NO_TILE;
}
if (y < 0) {
dst_y -= y;
height += y;
y = 0;
}
if (x >= src_surface->width) {
return;
}
if (y >= src_surface->height) {
return;
}
if (x + width > src_surface->width) {
width = src_surface->width - x;
// also switch right mode to erase
tile_right = TERMPAINT_COPY_NO_TILE;
}
if (y + height > src_surface->height) {
height = src_surface->height - y;
}
if (dst_x < 0) {
x -= dst_x;
width += dst_x;
dst_x = 0;
// also switch left mode to erase
tile_left = TERMPAINT_COPY_NO_TILE;
}
if (dst_y < 0) {
y -= dst_y;
height += dst_y;
dst_y = 0;
}
if (dst_x + width > dst_surface->width) {
width = dst_surface->width - dst_x;
// also switch right mode to erase
tile_right = TERMPAINT_COPY_NO_TILE;
}
if (tile_right >= TERMPAINT_COPY_TILE_PUT && dst_x + width + 1 >= dst_surface->width) {
tile_right = TERMPAINT_COPY_NO_TILE;
}
if (dst_y + height >= dst_surface->height) {
height = dst_surface->height - dst_y;
}
if (width == 0) {
return;
}
if (src_surface == dst_surface) {
termpaintp_surface_copy_rect_same_surface(src_surface, x, y, width, height, dst_x, dst_y, tile_left, tile_right);
return;
}
for (int yOffset = 0; yOffset < height; yOffset++) {
bool in_complete_cluster = false;
int xOffset = 0;
{
cell *src_cell = termpaintp_getcell(src_surface, x, y + yOffset);
if (src_cell->text_len == 0 && src_cell->text_overflow == WIDE_RIGHT_PADDING) {
if (tile_left == TERMPAINT_COPY_TILE_PRESERVE) {
for (int i = 0; i < width; i++) {
cell *src_scan = termpaintp_getcell(src_surface, x + i, y + yOffset);
cell *dst_scan = termpaintp_getcell(dst_surface, dst_x + i, dst_y + yOffset);
if (!(src_scan->text_len == 0 && src_scan->text_overflow == WIDE_RIGHT_PADDING)
&& !(dst_scan->text_len == 0 && dst_scan->text_overflow == WIDE_RIGHT_PADDING)) {
// end of cluster in both surfaces.
// skip over same length cluster in src and dst.
xOffset = i;
break;
}
if (!(dst_scan->text_len == 0 && dst_scan->text_overflow == WIDE_RIGHT_PADDING)) {
// cluster in dst is shorter than in src or shifted. This can not be valid tiling.
break;
}
if (i == width - 1) {
// whole line in src is one cluster, dst also has a cluster there
xOffset = width;
}
}
} else if (tile_left >= TERMPAINT_COPY_TILE_PUT && x > 0 && dst_x > 0) {
cell *src_scan = termpaintp_getcell(src_surface, x - 1, y + yOffset);
cell *dst_scan = termpaintp_getcell(dst_surface, dst_x - 1, dst_y + yOffset);
if ((src_scan->text_len != 0 || src_scan->text_overflow != WIDE_RIGHT_PADDING)
&& src_scan->cluster_expansion > 0
&& src_scan->cluster_expansion <= width) {
in_complete_cluster = true;
termpaintp_surface_vanish_char(dst_surface, dst_x - 1, dst_y + yOffset, src_scan->cluster_expansion + 1);
termpaintp_copy_colors_and_attibutes(src_surface, src_scan,
dst_surface, dst_scan);
dst_scan->cluster_expansion = src_scan->cluster_expansion;
if (src_scan->text_len > 0) {
memcpy(dst_scan->text, src_scan->text, src_scan->text_len);
dst_scan->text_len = src_scan->text_len;
} else if (src_scan->text_len == 0) {
termpaintp_set_overflow_text(dst_surface, dst_scan, src_scan->text_overflow->text);
}
}
}
}
}
int extra_width = 0;
for (; xOffset < width + extra_width; xOffset++) {
cell *src_cell = termpaintp_getcell(src_surface, x + xOffset, y + yOffset);
cell *dst_cell = termpaintp_getcell(dst_surface, dst_x + xOffset, dst_y + yOffset);
if (src_cell->text_len == 0 && src_cell->text_overflow == WIDE_RIGHT_PADDING) {
termpaintp_surface_vanish_char(dst_surface, dst_x + xOffset, dst_y + yOffset, 1);
termpaintp_copy_colors_and_attibutes(src_surface, src_cell,
dst_surface, dst_cell);
if (in_complete_cluster) {
dst_cell->text_len = 0;
dst_cell->text_overflow = WIDE_RIGHT_PADDING;
} else {
dst_cell->text_len = 1;
dst_cell->text[0] = ' ';
}
} else {
if (tile_right == TERMPAINT_COPY_TILE_PRESERVE) {
if (src_cell->cluster_expansion && xOffset + src_cell->cluster_expansion >= width) {
if (src_cell->cluster_expansion == dst_cell->cluster_expansion) {
// same cluster length in both, preserve cluster in dst
break;
}
}
}
const bool crosses_boundary = xOffset + src_cell->cluster_expansion >= width;
const bool write_over_boundary = tile_right >= TERMPAINT_COPY_TILE_PUT && src_cell->cluster_expansion == 1;
termpaintp_surface_vanish_char(dst_surface, dst_x + xOffset, dst_y + yOffset,
(crosses_boundary && !write_over_boundary) ? 1 : src_cell->cluster_expansion + 1);
termpaintp_copy_colors_and_attibutes(src_surface, src_cell,
dst_surface, dst_cell);
bool vanish = false;
if (src_cell->cluster_expansion) {
if (crosses_boundary) {
if (write_over_boundary) {
extra_width = 1;
dst_cell->cluster_expansion = src_cell->cluster_expansion;
in_complete_cluster = true;
} else {
vanish = true;
in_complete_cluster = false;
}
} else {
dst_cell->cluster_expansion = src_cell->cluster_expansion;
in_complete_cluster = true;
}
} else {
in_complete_cluster = false;
}
if (!vanish) {
if (src_cell->text_len > 0) {
memcpy(dst_cell->text, src_cell->text, src_cell->text_len);
dst_cell->text_len = src_cell->text_len;
} else if (src_cell->text_len == 0) {
if (src_cell->text_overflow != nullptr) {
termpaintp_set_overflow_text(dst_surface, dst_cell, src_cell->text_overflow->text);
} else {
dst_cell->text_len = 0;
dst_cell->text_overflow = nullptr;
}
}
} else {
dst_cell->text_len = 1;
dst_cell->text[0] = ' ';
}
}
}
}
}
static void termpaintp_surface_copy_rect_same_surface(termpaint_surface *dst_surface, int x, int y, int width, int height,
int dst_x, int dst_y, int tile_left, int tile_right) {
// precondition: All rectangles are already fully within the surface.
termpaint_surface *src_surface = termpaint_surface_new_surface(dst_surface,
width + (x != 0 ? 1 : 0) + ((x + width != dst_surface->width) ? 1 : 0),
height + (y != 0 ? 1 : 0) + ((y + height != dst_surface->height) ? 1 : 0));
termpaint_surface_copy_rect(dst_surface, x - (x != 0 ? 1 : 0), y - (y != 0 ? 1 : 0), src_surface->width, src_surface->height,
src_surface, 0, 0,
TERMPAINT_COPY_NO_TILE, TERMPAINT_COPY_NO_TILE);
termpaint_surface_copy_rect(src_surface, (x != 0 ? 1 : 0), (y != 0 ? 1 : 0), width, height,
dst_surface, dst_x, dst_y,
tile_left, tile_right);
termpaint_surface_free(src_surface);
}
termpaint_surface *termpaint_surface_duplicate(termpaint_surface *surface) {
termpaint_surface *ret = termpaint_surface_new_surface(surface, surface->width, surface->height);
termpaint_surface_copy_rect(surface, 0, 0, surface->width, surface->height,
ret, 0, 0,
TERMPAINT_COPY_NO_TILE, TERMPAINT_COPY_NO_TILE);
return ret;
}
unsigned termpaint_surface_peek_fg_color(const termpaint_surface *surface, int x, int y) {
cell *cell = termpaintp_getcell_or_null(surface, x, y);
if (!cell) {
return 0;
}
return cell->fg_color;
}
unsigned termpaint_surface_peek_bg_color(const termpaint_surface *surface, int x, int y) {
cell *cell = termpaintp_getcell_or_null(surface, x, y);
if (!cell) {
return 0;
}
return cell->bg_color;
}
unsigned termpaint_surface_peek_deco_color(const termpaint_surface *surface, int x, int y) {
cell *cell = termpaintp_getcell_or_null(surface, x, y);
if (!cell) {
return 0;
}
return cell->deco_color;
}
int termpaint_surface_peek_style(const termpaint_surface *surface, int x, int y) {
cell *cell = termpaintp_getcell_or_null(surface, x, y);
if (!cell) {
return 0;
}
unsigned flags = cell->flags;
int style = flags & TERMPAINT_STYLE_PASSTHROUGH;
if ((flags & CELL_ATTR_UNDERLINE_MASK) == CELL_ATTR_UNDERLINE_SINGLE) {
style |= TERMPAINT_STYLE_UNDERLINE;
} else if ((flags & CELL_ATTR_UNDERLINE_MASK) == CELL_ATTR_UNDERLINE_DOUBLE) {
style |= TERMPAINT_STYLE_UNDERLINE_DBL;
} else if ((flags & CELL_ATTR_UNDERLINE_MASK) == CELL_ATTR_UNDERLINE_CURLY) {
style |= TERMPAINT_STYLE_UNDERLINE_CURLY;
}
return style;
}
void termpaint_surface_peek_patch(const termpaint_surface *surface, int x, int y, const char **setup, const char **cleanup, bool *optimize) {
cell *cell = termpaintp_getcell_or_null(surface, x, y);
if (!cell || !cell->attr_patch_idx) {
*setup = nullptr;
*cleanup = nullptr;
*optimize = true;
return;
}
termpaintp_patch* patch = &surface->patches[cell->attr_patch_idx - 1];
*setup = (const char *)patch->setup;
*cleanup = (const char *)patch->cleanup;
*optimize = patch->optimize;
}
const char *termpaint_surface_peek_text(const termpaint_surface *surface, int x, int y, int *len, int *left, int *right) {
cell *cell = termpaintp_getcell_or_null(surface, x, y);
if (!cell) {
if (left) {
*left = x;
}
if (right) {
*right = x;
}
*len = 1;
return TERMPAINT_ERASED;
}
while (x > 0) {
if (cell->text_len != 0 || cell->text_overflow != WIDE_RIGHT_PADDING) {
break;
}
--x;
cell = termpaintp_getcell(surface, x, y);
}
if (left) {
*left = x;
}
const char *text;
if (cell->text_len > 0) {
text = (const char*)cell->text;
*len = cell->text_len;
} else if (cell->text_overflow == nullptr) {
text = TERMPAINT_ERASED;
*len = 1;
} else {
text = (const char*)cell->text_overflow->text;
*len = strlen(text);
}
if (right) {
*right = x + cell->cluster_expansion;
}
return text;
}
bool termpaint_surface_peek_softwrap_marker(const termpaint_surface *surface, int x, int y) {
cell *cell = termpaintp_getcell_or_null(surface, x, y);
if (!cell) {
return false;
}
return !!(cell->flags & CELL_SOFTWRAP_MARKER);
}
bool termpaint_surface_same_contents(const termpaint_surface *surface1, const termpaint_surface *surface2) {
if (surface1 == surface2) {
return true;
}
if (surface1->width != surface2->width
|| surface1->height != surface2->height) {
return false;
}
for (int y = 0; y < surface1->height; y++) {
for (int x = 0; x < surface1->width; x++) {
if (termpaint_surface_peek_fg_color(surface1, x, y)
!= termpaint_surface_peek_fg_color(surface2, x, y)) {
return false;
}
if (termpaint_surface_peek_bg_color(surface1, x, y)
!= termpaint_surface_peek_bg_color(surface2, x, y)) {
return false;
}
if (termpaint_surface_peek_deco_color(surface1, x, y)
!= termpaint_surface_peek_deco_color(surface2, x, y)) {
return false;
}
if (termpaint_surface_peek_style(surface1, x, y)
!= termpaint_surface_peek_style(surface2, x, y)) {
return false;
}
if (termpaint_surface_peek_softwrap_marker(surface1, x, y)
!= termpaint_surface_peek_softwrap_marker(surface2, x, y)) {
return false;
}
{
const char *setup1, *setup2;
const char *cleanup1, *cleanup2;
bool optimize1, optimize2;
termpaint_surface_peek_patch(surface1, x, y, &setup1, &cleanup1, &optimize1);
termpaint_surface_peek_patch(surface2, x, y, &setup2, &cleanup2, &optimize2);
if ((setup1 == nullptr || setup2 == nullptr || strcmp(setup1, setup2) != 0) && !(setup1 == nullptr && setup2 == nullptr)) {
return false;
}
if ((cleanup1 == nullptr || cleanup2 == nullptr || strcmp(cleanup1, cleanup2) != 0) && !(setup1 == nullptr && setup2 == nullptr)) {
return false;
}
if (optimize1 != optimize2) {
return false;
}
}
{
int left1, right1, len1;
int left2, right2, len2;
const char *text1 = termpaint_surface_peek_text(surface1, x, y, &len1, &left1, &right1);
const char *text2 = termpaint_surface_peek_text(surface2, x, y, &len2, &left2, &right2);
if (left1 != left2 || right1 != right2 || len1 != len2) {
return false;
}
if (memcmp(text1, text2, len1) != 0) {
return false;
}
}
}
}
return true;
}
int termpaint_surface_char_width(const termpaint_surface *surface, int codepoint) {
const termpaintp_width *char_width_table = surface->terminal->char_width_table;
return termpaintp_char_width(char_width_table, codepoint);
}
static void int_puts(termpaint_integration *integration, const char *str) {
integration->p->write(integration, str, strlen(str));
}
static void int_uputs(termpaint_integration *integration, const unsigned char *str) {
integration->p->write(integration, (const char*)str, ustrlen(str));
}
static void int_write(termpaint_integration *integration, const char *str, int len) {
integration->p->write(integration, str, len);
}
static void int_debuglog(termpaint_terminal *term, const char *str, int len) {
if (term->integration_vtbl->logging_func) {
term->integration_vtbl->logging_func(term->integration, str, len);
}
}
static void int_debuglog_puts(termpaint_terminal *term, const char *str) {
int_debuglog(term, str, strlen(str));
}
static void int_debuglog_printf(termpaint_terminal *term, const char *fmt, ...) {
va_list args;
va_start(args, fmt);
char buff[1024];
vsnprintf(buff, sizeof(buff), fmt, args);
va_end(args);
buff[sizeof(buff) - 1] = 0;
int_debuglog_puts(term, buff);
}
static void int_put_num(termpaint_integration *integration, int num) {
char buf[12];
int len = sprintf(buf, "%d", num);
integration->p->write(integration, buf, len);
}
static void int_put_tps(termpaint_integration *integration, const termpaint_str *tps) {
integration->p->write(integration, (const char*)tps->data, (int)tps->len);
}
static void int_awaiting_response(termpaint_integration *integration) {
if (integration->p->awaiting_response) {
integration->p->awaiting_response(integration);
}
}
static void int_restore_sequence_complete(termpaint_terminal *term) {
if (term->altscreen_active) {
termpaintp_str_assign_n(&term->restore_seq_cached, (const char*)term->restore_seq_partial.data, term->restore_seq_partial.len);
termpaintp_str_append(&term->restore_seq_cached, "\r\n\033[?1049l");
} else {
termpaintp_str_assign_n(&term->restore_seq_cached, (const char*)term->restore_seq_partial.data, term->restore_seq_partial.len);
}
}
static void int_restore_sequence_updated(termpaint_terminal *term) {
termpaint_integration_private *vtbl = term->integration_vtbl;
if (vtbl->restore_sequence_updated) {
vtbl->restore_sequence_updated(term->integration, (char*)term->restore_seq_cached.data, term->restore_seq_cached.len);
}
}
static void int_flush(termpaint_integration *integration) {
integration->p->flush(integration);
}
static void termpaintp_terminal_set_cursor(termpaint_terminal *term, int x, int y) {
termpaint_integration *integration = term->integration;
int_puts(integration, "\033[");
int_put_num(integration, y+1);
int_puts(integration, ";");
int_put_num(integration, x+1);
int_puts(integration, "H");
}
static void termpaintp_terminal_hide_cursor(termpaint_terminal *term) {
termpaint_integration *integration = term->integration;
int_puts(integration, "\033[?25l");
}
static void termpaintp_terminal_show_cursor(termpaint_terminal *term) {
termpaint_integration *integration = term->integration;
int_puts(integration, "\033[?25h");
}
static void termpaintp_terminal_update_cursor_style(termpaint_terminal *term) {
bool nonharmful = termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE);
if (term->cursor_style != -1 && nonharmful) {
const char *resetSequence = "\033[0 q";
int cmd = term->cursor_style + (term->cursor_blink ? 0 : 1);
if (term->cursor_style == TERMPAINT_CURSOR_STYLE_BAR
&& !termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE_BAR)) {
// e.g. xterm < 282 does not support BAR style.
cmd = TERMPAINT_CURSOR_STYLE_BLOCK + (term->cursor_blink ? 0 : 1);
}
if (cmd != term->cursor_prev_data) {
termpaint_integration *integration = term->integration;
if (termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_CURSOR_SHAPE_OSC50)) {
// e.g. konsole. (konsole starting at version 18.07.70 could do the CSI space q one too, but
// we don't have the konsole version.)
if (term->cursor_style == TERMPAINT_CURSOR_STYLE_BAR) {
int_puts(integration, "\x1b]50;CursorShape=1;BlinkingCursorEnabled=");
} else if (term->cursor_style == TERMPAINT_CURSOR_STYLE_UNDERLINE) {
int_puts(integration, "\x1b]50;CursorShape=2;BlinkingCursorEnabled=");
} else {
int_puts(integration, "\x1b]50;CursorShape=0;BlinkingCursorEnabled=");
}
if (term->cursor_blink) {
int_puts(integration, "1\a");
} else {
int_puts(integration, "0\a");
}
resetSequence = "\x1b]50;CursorShape=0;BlinkingCursorEnabled=0\a";
} else {
int_puts(integration, "\033[");
int_put_num(integration, cmd);
int_puts(integration, " q");
}
}
if (term->cursor_prev_data == -1) {
// add style reset. We don't know the original style, so just reset to terminal default.
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)resetSequence);
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
}
term->cursor_prev_data = cmd;
}
}
static void termpaintp_input_event_callback(void *user_data, termpaint_event *event);
static bool termpaintp_input_raw_filter_callback(void *user_data, const char *data, unsigned length, _Bool overflow);
static void termpaint_color_entry_destroy(termpaint_color_entry *entry) {
termpaintp_str_destroy(&entry->restore);
termpaintp_str_destroy(&entry->requested);
}
static void termpaint_unpause_snippet_destroy(termpaint_unpause_snippet *entry) {
termpaintp_str_destroy(&entry->sequences);
}
static void termpaintp_terminal_reset_capabilites(termpaint_terminal *terminal);
termpaint_terminal *termpaint_terminal_new_or_nullptr(termpaint_integration *integration) {
termpaint_terminal *ret = calloc(1, sizeof(termpaint_terminal));
if (!ret) {
return nullptr;
}
termpaintp_surface_init(&ret->primary, ret);
ret->primary.primary = true;
// start collapsed
termpaintp_collapse(&ret->primary);
ret->integration = integration;
ret->integration_vtbl = integration->p;
ret->inline_current_terminal_cursor_line = -1;
ret->cursor_visible = true;
ret->cursor_x = -1;
ret->cursor_y = -1;
ret->cursor_style = -1;
ret->cursor_blink = false;
ret->cursor_prev_data = -1;
ret->data_pending_after_input_received = false;
ret->ad_state = AD_NONE;
ret->initial_cursor_x = -1;
ret->initial_cursor_y = -1;
ret->char_width_table = &termpaintp_char_width_default;
termpaintp_terminal_reset_capabilites(ret);
ret->terminal_type = TT_UNKNOWN;
ret->terminal_type_confidence = 0;
ret->max_csi_parameters = 15;
ret->input = termpaint_input_new();
if (!ret->input) {
free(ret);
return nullptr;
}
termpaint_input_set_event_cb(ret->input, termpaintp_input_event_callback, ret);
termpaint_input_set_raw_filter_cb(ret->input, termpaintp_input_raw_filter_callback, ret);
ret->colors.item_size = sizeof(termpaint_color_entry);
ret->colors.destroy_cb = (void (*)(termpaint_hash_item*))termpaint_color_entry_destroy;
ret->unpause_snippets.item_size = sizeof (termpaint_unpause_snippet);
ret->unpause_snippets.destroy_cb = (void (*)(termpaint_hash_item*))termpaint_unpause_snippet_destroy;
if (!termpaintp_str_preallocate(&ret->unpause_basic_setup, 64)) {
termpaint_input_free(ret->input);
free(ret);
return nullptr;
}
if (!termpaintp_str_preallocate(&ret->restore_seq_cached, 256)) {
termpaintp_str_destroy(&ret->unpause_basic_setup);
termpaint_input_free(ret->input);
free(ret);
return nullptr;
}
if (!termpaintp_str_preallocate(&ret->restore_seq_partial, 256)) {
termpaintp_str_destroy(&ret->restore_seq_cached);
termpaintp_str_destroy(&ret->unpause_basic_setup);
termpaint_input_free(ret->input);
free(ret);
return nullptr;
}
if (!termpaintp_str_preallocate(&ret->terminal_self_reported_name_version, 64)) {
termpaintp_str_destroy(&ret->restore_seq_partial);
termpaintp_str_destroy(&ret->restore_seq_cached);
termpaintp_str_destroy(&ret->unpause_basic_setup);
termpaint_input_free(ret->input);
free(ret);
return nullptr;
}
if (!termpaintp_str_preallocate(&ret->auto_detect_sec_device_attributes, 64)) {
termpaintp_str_destroy(&ret->terminal_self_reported_name_version);
termpaintp_str_destroy(&ret->restore_seq_partial);
termpaintp_str_destroy(&ret->restore_seq_cached);
termpaintp_str_destroy(&ret->unpause_basic_setup);
termpaint_input_free(ret->input);
free(ret);
return nullptr;
}
termpaintp_prepend_str(&ret->restore_seq_partial, (const uchar*)"\033[?25h\033[m");
int_restore_sequence_complete(ret);
int_restore_sequence_updated(ret);
return ret;
}
termpaint_terminal *termpaint_terminal_new(termpaint_integration *integration) {
termpaint_terminal *ret = termpaint_terminal_new_or_nullptr(integration);
if (!ret) {
termpaintp_oom_int(integration);
}
return ret;
}
void termpaint_terminal_set_log_mask(termpaint_terminal *term, unsigned mask) {
term->log_mask = mask;
}
void termpaint_terminal_glitch_on_out_of_memory(termpaint_terminal *term) {
term->glitch_on_oom = true;
}
void termpaint_terminal_free(termpaint_terminal *term) {
if (!term) {
return;
}
termpaintp_str_destroy(&term->auto_detect_sec_device_attributes);
termpaintp_str_destroy(&term->terminal_self_reported_name_version);
termpaintp_surface_destroy(&term->primary);
termpaintp_str_destroy(&term->restore_seq_partial);
termpaintp_str_destroy(&term->restore_seq_cached);
termpaint_input_free(term->input);
term->input = nullptr;
term->integration_vtbl->free(term->integration);
term->integration = nullptr;
term->integration_vtbl = nullptr;
termpaintp_str_destroy(&term->unpause_basic_setup);
termpaintp_hash_destroy(&term->colors);
termpaintp_hash_destroy(&term->unpause_snippets);
free(term);
}
static void termpaintp_erase_inline(termpaint_terminal *term) {
termpaint_integration *integration = term->integration;
int to_move = term->last_inline_height - 1 - term->inline_current_terminal_cursor_line;
int_puts(integration, "\r");
if (to_move > 0) {
int_puts(integration, "\033[");
int_put_num(integration, to_move);
int_puts(integration, "B");
}
int_write(integration, "\033[K", 3);
for (int i = 1; i < term->last_inline_height; i++) {
int_write(integration, "\033[A", 3);
int_write(integration, "\033[K", 3);
}
term->inline_current_terminal_cursor_line = 0;
term->last_inline_height = 0;
}
static void termpaintp_terminal_flush_with_surface(termpaint_terminal *term, bool full_repaint, termpaint_surface *surface);
void termpaint_terminal_free_with_restore(termpaint_terminal *term) {
termpaint_terminal_free_with_restore_and_persistent(term, nullptr);
}
void termpaint_terminal_free_with_restore_and_persistent(termpaint_terminal *term, termpaint_surface *surface) {
if (!term) {
return;
}
termpaint_integration *integration = term->integration;
if (term->setup_state != SETUP_STATE_INLINE) {
if (term->primary.height && term->primary.height) {
termpaintp_terminal_set_cursor(term, 0, term->primary.height - 1);
}
if (surface) {
if (term->altscreen_active) {
int_puts(integration, "\033[?1049l");
term->altscreen_active = false;
int_restore_sequence_complete(term);
}
term->setup_state = SETUP_STATE_INLINE;
term->inline_current_terminal_cursor_line = 0;
term->last_inline_height = 0;
term->cursor_x = term->cursor_y = -1;
termpaintp_terminal_flush_with_surface(term, true, surface);
int_puts(integration, "\r\n");
// Output is persistent
term->inline_current_terminal_cursor_line = 0;
term->last_inline_height = 0;
}
} else {
termpaintp_erase_inline(term);
if (surface) {
term->cursor_x = term->cursor_y = -1;
termpaintp_terminal_flush_with_surface(term, true, surface);
int_puts(integration, "\r\n");
// Output is persistent
term->inline_current_terminal_cursor_line = 0;
term->last_inline_height = 0;
}
}
if (term->restore_seq_cached.len) {
int_write(integration, (const char*)term->restore_seq_cached.data, term->restore_seq_cached.len);
}
int_flush(integration);
termpaint_terminal_free(term);
}
static void termpaintp_terminal_reset_capabilites(termpaint_terminal *terminal) {
for (int i = 0; i < NUM_CAPABILITIES; i++) {
terminal->capabilities[i] = false;
}
// cursor bar is on by default. Some terminals don't understand any sequence, for these this does not matter.
// But some terminals recognize block and underline, but ignore bar. In this case it's better to remap bar to block.
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE_BAR);
// Start with assuming that terminals have in principle solid support for unicode fonts with common
// linedrawing / semigraphics codepoints. But leave this to opt out for implementations with very
// limited character repertoire.
// One example is the kernel internal terminal in linux that is limited to 256 or 512 different glyphs total.
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_EXTENDED_CHARSET);
// Start with assuming a terminal might have true-color support. If a terminal (+ version) is known
// not to support true-color this capability should be removed during detection. If a terminal (+ version)
// is known to support true-color additionally set TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED during
// detection
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED);
// Most terminals support background color erase (bce) and allow multiple colors in cleared parts
// of lines.
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CLEARED_COLORING);
// VTE specific quirk
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CLEARED_COLORING_DEFCOLOR);
// Most terminals support support 7-bit ST (ESC backslash) for terminating OSC/DCS sequences,
// as that's what all traditional standards say.
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_7BIT_ST);
}
inline bool termpaint_terminal_capable(const termpaint_terminal *terminal, int capability) {
if (capability < 0 || capability >= NUM_CAPABILITIES) {
return false;
}
return terminal->capabilities[capability];
}
static char* termpaintp_terminal_correct_string_terminator(const termpaint_terminal *terminal) {
if (termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_7BIT_ST)) {
return "\033\\";
} else {
return "\a";
}
}
static void termpaintp_update_cache_from_capabilities(termpaint_terminal *terminal) {
terminal->cache_should_use_truecolor =
termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED)
|| termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
}
void termpaint_terminal_promise_capability(termpaint_terminal *terminal, int capability) {
if (capability < 0 || capability >= NUM_CAPABILITIES) {
return;
}
terminal->capabilities[capability] = true;
termpaintp_update_cache_from_capabilities(terminal);
}
void termpaint_terminal_disable_capability(termpaint_terminal *terminal, int capability) {
if (capability < 0 || capability >= NUM_CAPABILITIES) {
return;
}
terminal->capabilities[capability] = false;
termpaintp_update_cache_from_capabilities(terminal);
}
bool termpaint_terminal_should_use_truecolor(termpaint_terminal *terminal) {
return terminal->cache_should_use_truecolor;
}
termpaint_surface *termpaint_terminal_get_surface(termpaint_terminal *term) {
return &term->primary;
}
static int termpaintp_quantize_color_grid6(int val) {
// index of nearest int to [0, 95, 135, 175, 215, 255]
// cut points: 47, 115, 155, 195, 235
if (val <= 47) {
return 0;
}
if (val < 115) {
return 1;
}
return 2 + (val - 115) / 40;
}
static int termpaintp_quantize_color_grid4(int val) {
// index of nearest int to [0, 139, 205, 255]
// cut points: 69, 172, 230
if (val <= 172) {
if (val <= 69) {
return 0;
} else {
return 1;
}
} else {
if (val < 230) {
return 2;
} else {
return 3;
}
}
}
static const int termpaintp_grid6_values[] = {0, 95, 135, 175, 215, 255};
static const int termpaintp_grid4_values[] = {0, 139, 205, 255};
static const int termpaintp_ramp8_values[] = {46, 92, 115, 139, 162, 185, 208, 231};
static uint32_t termpaintp_quantize_color(termpaint_terminal *term, uint32_t color) {
if (!term->cache_should_use_truecolor) {
if ((color & 0xff000000) == TERMPAINT_RGB_COLOR_OFFSET) {
const int r = (color >> 16) & 0xff;
const int g = (color >> 8) & 0xff;
const int b = (color) & 0xff;
const int grey = (r+g+b) / 3;
if (termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_88_COLOR)) {
// find nearest color on grid ((r,g,b) for r,b,g in [0, 95, 135, 175, 215, 255])
const int red_index = termpaintp_quantize_color_grid4(r);
const int green_index = termpaintp_quantize_color_grid4(g);
const int blue_index = termpaintp_quantize_color_grid4(b);
const int red_quantized = termpaintp_grid4_values[red_index];
const int green_quantized = termpaintp_grid4_values[green_index];
const int blue_quantized = termpaintp_grid4_values[blue_index];
color = TERMPAINT_INDEXED_COLOR + 16 + red_index * 16 + green_index * 4 + blue_index;
#define SQ(x) ((x) * (x))
int best_metric = SQ(red_quantized - r) + SQ(green_quantized - g) + SQ(blue_quantized - b);
for (int grey_index = 0; grey_index < 8; grey_index++) {
const int grey_quantized = termpaintp_ramp8_values[grey_index];
const int cur_metric = SQ(grey_quantized - r) + SQ(grey_quantized - g) + SQ(grey_quantized - b);
if (cur_metric < best_metric) {
color = TERMPAINT_INDEXED_COLOR + 80 + grey_index;
best_metric = cur_metric;
}
}
#undef SQ
} else {
// find nearest grey value in [8, 18, ..., 228, 238]
int grey_index = (((grey - 8)+5) / 10); // -3 / 10 rounds to zero, so grey == 0 still gives index 0
if (grey_index >= 24) {
grey_index = 23;
}
const int grey_quantized = 8 + grey_index * 10;
// find nearest color on grid ((r,g,b) for r,b,g in [0, 95, 135, 175, 215, 255])
const int red_index = termpaintp_quantize_color_grid6(r);
const int green_index = termpaintp_quantize_color_grid6(g);
const int blue_index = termpaintp_quantize_color_grid6(b);
const int red_quantized = termpaintp_grid6_values[red_index];
const int green_quantized = termpaintp_grid6_values[green_index];
const int blue_quantized = termpaintp_grid6_values[blue_index];
#define SQ(x) ((x) * (x))
if ((SQ(grey_quantized - r) + SQ(grey_quantized - g) + SQ(grey_quantized - b))
< (SQ(red_quantized - r) + SQ(green_quantized - g) + SQ(blue_quantized - b))) {
#undef SQ
color = TERMPAINT_INDEXED_COLOR + 232 + grey_index;
} else {
color = TERMPAINT_INDEXED_COLOR + 16
+ red_index * 36
+ green_index * 6
+ blue_index;
}
}
}
}
return color;
}
typedef struct {
int index;
int max;
} termpaintp_sgr_params;
static inline void write_color_sgr_values(termpaint_integration *integration, termpaintp_sgr_params *params, uint32_t color, char *direct, char *indexed, char *sep, unsigned named, unsigned bright_named) {
if ((color & 0xff000000) == TERMPAINT_RGB_COLOR_OFFSET) {
if (params->index + 5 >= params->max) {
int_puts(integration, "m\033[");
params->index = 0;
int_puts(integration, direct + 1); // skip first ";"
} else {
int_puts(integration, direct);
}
int_put_num(integration, (color >> 16) & 0xff);
int_puts(integration, sep);
int_put_num(integration, (color >> 8) & 0xff);
int_puts(integration, sep);
int_put_num(integration, (color) & 0xff);
params->index += 5;
} else if (TERMPAINT_INDEXED_COLOR <= color && TERMPAINT_INDEXED_COLOR + 255 >= color) {
if (params->index + 3 >= params->max) {
int_puts(integration, "m\033[");
params->index = 0;
int_puts(integration, indexed + 1); // skip first ";"
} else {
int_puts(integration, indexed);
}
int_put_num(integration, (color) & 0xff);
params->index += 3;
} else {
if (named) {
if (TERMPAINT_NAMED_COLOR <= color && TERMPAINT_NAMED_COLOR + 7 >= color) {
if (params->index + 1 >= params->max) {
int_puts(integration, "m\033[");
params->index = 0;
} else {
int_puts(integration, ";");
}
int_put_num(integration, named + (color - TERMPAINT_NAMED_COLOR));
params->index += 1;
} else if (TERMPAINT_NAMED_COLOR + 8 <= color && TERMPAINT_NAMED_COLOR + 15 >= color) {
if (params->index + 1 >= params->max) {
int_puts(integration, "m\033[");
params->index = 0;
} else {
int_puts(integration, ";");
}
int_put_num(integration, bright_named + (color - (TERMPAINT_NAMED_COLOR + 8)));
params->index += 1;
}
} else {
if (TERMPAINT_NAMED_COLOR <= color && TERMPAINT_NAMED_COLOR + 15 >= color) {
if (params->index + 3 >= params->max) {
int_puts(integration, "m\033[");
params->index = 0;
int_puts(integration, indexed + 1); // skip first ";"
} else {
int_puts(integration, indexed);
}
int_put_num(integration, (color - TERMPAINT_NAMED_COLOR));
params->index += 3;
}
}
}
}
static void termpaintp_terminal_flush_with_surface(termpaint_terminal *term, bool full_repaint, termpaint_surface *surface) {
termpaint_integration *integration = term->integration;
if (surface == &term->primary) {
full_repaint |= term->force_full_repaint;
term->force_full_repaint = false;
}
termpaintp_terminal_hide_cursor(term);
if (term->setup_state == SETUP_STATE_INLINE) {
int_puts(integration, "\r");
if (term->inline_current_terminal_cursor_line != 0) {
int_puts(integration, "\033[");
int_put_num(integration, term->inline_current_terminal_cursor_line);
int_puts(integration, "A");
}
if (surface->height < term->last_inline_height) {
int_puts(integration, "\033[");
int_put_num(integration, term->last_inline_height - 1);
int_puts(integration, "B");
int_write(integration, "\033[K", 3);
for (int i = 1; i < term->last_inline_height - surface->height; i++) {
int_puts(integration, "\033[A\033[K");
}
int_puts(integration, "\033[");
int_put_num(integration, surface->height);
int_puts(integration, "A");
}
term->last_inline_height = surface->height;
} else {
int_puts(integration, "\033[H");
}
char speculation_buffer[30];
int speculation_buffer_state = 0; // 0 = cursor position matches current cell, -1 = force move, > 0 bytes to print instead of move
int pending_row_move = 0;
int pending_colum_move = 0;
int pending_colum_move_digits = 1;
int pending_colum_move_digits_step = 10;
const bool cleared_defcolor = termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_CLEARED_COLORING_DEFCOLOR);
enum { sw_no, sw_single, sw_double } softwrap_prev = sw_no, softwrap = sw_no;
for (int y = 0; y < surface->height; y++) {
speculation_buffer_state = 0;
pending_colum_move = 0;
pending_colum_move_digits = 1;
pending_colum_move_digits_step = 10;
uint32_t current_fg = -1;
uint32_t current_bg = -1;
uint32_t current_deco = -1;
uint32_t current_flags = -1;
uint32_t current_patch_idx = 0; // patch index is special because it could do anything.
bool cleared = false;
softwrap = sw_no;
if (y+1 < surface->height && surface->width) {
cell* first_next_line = termpaintp_getcell(surface, 0, y + 1);
if (first_next_line->flags & CELL_SOFTWRAP_MARKER
&& (first_next_line->text_len || first_next_line->text_overflow != nullptr)) {
cell* last_this_line = termpaintp_getcell(surface, surface->width - 1, y);
if (last_this_line->flags & CELL_SOFTWRAP_MARKER
&& (last_this_line->text_len || last_this_line->text_overflow != nullptr)) {
softwrap = sw_single;
} else if (last_this_line->text_len == 0
&& last_this_line->text_overflow == nullptr
&& surface->width >= 2) {
last_this_line = termpaintp_getcell(surface, surface->width - 2, y);
if (last_this_line->flags & CELL_SOFTWRAP_MARKER
&& (last_this_line->text_len || last_this_line->text_overflow != nullptr)
&& first_next_line->cluster_expansion == 1) {
softwrap = sw_double;
}
}
}
}
int first_noncopy_space = surface->width;
if (termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_CLEARED_COLORING)) {
if (softwrap == sw_no) {
for (int x = surface->width - 1; x >= 0; x--) {
cell* c = termpaintp_getcell(surface, x, y);
if ((c->text_len == 0 && c->text_overflow == nullptr)
&& (c->flags & CELL_ATTR_INVERSE) == 0
&& (cleared_defcolor || c->bg_color != TERMPAINT_DEFAULT_COLOR)) {
first_noncopy_space = x;
} else {
break;
}
}
}
}
for (int x = 0; x < surface->width; x++) {
cell* c = termpaintp_getcell(surface, x, y);
cell* old_c = surface->cells_last_flush ? &surface->cells_last_flush[y*surface->width+x] : c;
int code_units;
bool text_changed;
const unsigned char* text;
if (c->text_len) {
code_units = c->text_len;
text = c->text;
text_changed = old_c->text_len != c->text_len || memcmp(text, old_c->text, code_units) != 0;
} else {
if (c->text_overflow == nullptr) {
code_units = 1;
text = (const uchar*)" ";
text_changed = old_c->text_len || c->text_overflow != old_c->text_overflow;
} else {
// TODO should we avoid crash here when cluster skipping failed?
code_units = strlen((char*)c->text_overflow->text);
text = c->text_overflow->text;
text_changed = old_c->text_len || c->text_overflow != old_c->text_overflow;
}
}
uint32_t effective_fg_color = termpaintp_quantize_color(term, c->fg_color);
uint32_t effective_bg_color = termpaintp_quantize_color(term, c->bg_color);
bool needs_paint = full_repaint || effective_bg_color != old_c->bg_color || effective_fg_color != old_c->fg_color
|| c->flags != old_c->flags || c->attr_patch_idx != old_c->attr_patch_idx || text_changed;
uint32_t effective_deco_color;
if (c->flags & CELL_ATTR_DECO_MASK) {
effective_deco_color = c->deco_color;
needs_paint |= effective_deco_color != old_c->deco_color;
} else {
effective_deco_color = TERMPAINT_DEFAULT_COLOR;
}
bool needs_attribute_change = effective_bg_color != current_bg || effective_fg_color != current_fg
|| effective_deco_color != current_deco || (c->flags & CELL_ATTR_MASK) != current_flags
|| c->attr_patch_idx != current_patch_idx;
if (first_noncopy_space < x) {
needs_paint = needs_attribute_change || (needs_paint && !cleared);
}
if (softwrap == sw_single && x == surface->width - 1) {
needs_paint = true;
if (term->did_terminal_disable_wrap) {
// terminals like urxvt, screen and libvterm need this before the cursor goes
// into pending wrap state.
int_puts(integration, "\033[?7h");
}
}
if (softwrap == sw_double && x == surface->width - 2) {
needs_paint = true;
x += 1; // skip last cell
if (term->did_terminal_disable_wrap) {
// terminals like urxvt, screen and libvterm need this before the cursor goes
// into pending wrap state.
int_puts(integration, "\033[?7h");
}
}
if (softwrap_prev != sw_no) {
needs_paint = true;
}
*old_c = *c;
old_c->bg_color = effective_bg_color;
old_c->fg_color = effective_fg_color;
if (surface->cells_last_flush) {
for (int i = 0; i < c->cluster_expansion; i++) {
cell* wipe_c = &surface->cells_last_flush[y*surface->width+x+i+1];
wipe_c->text_len = 1;
wipe_c->text[0] = '\x01'; // impossible value, filtered out earlier in output pipeline
}
}
if (!needs_paint) {
if (current_patch_idx) {
int_uputs(integration, surface->patches[current_patch_idx-1].cleanup);
current_patch_idx = 0;
}
pending_colum_move += 1 + c->cluster_expansion;
if (speculation_buffer_state != -1) {
if (needs_attribute_change) {
// needs_attribute_change needs >= 24 chars, so repositioning will likely be cheaper (and easier to implement)
speculation_buffer_state = -1;
} else {
if (pending_colum_move >= pending_colum_move_digits_step) {
pending_colum_move_digits += 1;
pending_colum_move_digits_step *= 10;
}
if (pending_colum_move_digits + 3 < speculation_buffer_state + code_units) {
// the move sequence is shorter than moving by printing chars
speculation_buffer_state = -1;
} else if (speculation_buffer_state + code_units < (int)sizeof (speculation_buffer)) {
memcpy(speculation_buffer + speculation_buffer_state, (char*)text, code_units);
} else {
// speculation buffer to small
speculation_buffer_state = -1;
}
}
}
x += c->cluster_expansion;
continue;
} else {
if (pending_row_move) {
int_puts(integration, "\r");
if (pending_row_move < 4) {
while (pending_row_move) {
int_puts(integration, "\n");
--pending_row_move;
}
} else {
int_puts(integration, "\033[");
int_put_num(integration, pending_row_move);
int_puts(integration, "B");
pending_row_move = 0;
}
}
if (pending_colum_move) {
if (speculation_buffer_state > 0) {
int_write(integration, speculation_buffer, speculation_buffer_state);
} else {
int_puts(integration, "\033[");
if (pending_colum_move != 1) {
int_put_num(integration, pending_colum_move);
}
int_puts(integration, "C");
}
speculation_buffer_state = 0;
pending_colum_move = 0;
pending_colum_move_digits = 1;
pending_colum_move_digits_step = 10;
}
}
if (needs_attribute_change) {
int_puts(integration, "\033[0");
termpaintp_sgr_params params;
params.index = 1;
params.max = term->max_csi_parameters;
#define PUT_PARAMETER(s) \
do { if (params.index + 1 >= params.max) { \
int_puts(integration, "m\033["); \
int_puts(integration, ((const char*)s) + 1); \
params.index = 1; \
} else { \
int_puts(integration, s); \
params.index += 1; \
} } while (false) \
/* end macro */
write_color_sgr_values(integration, ¶ms, effective_bg_color, ";48;2;", ";48;5;", ";", 40, 100);
write_color_sgr_values(integration, ¶ms, effective_fg_color, ";38;2;", ";38;5;", ";", 30, 90);
write_color_sgr_values(integration, ¶ms, effective_deco_color, ";58:2:", ";58:5:", ":", 0, 0);
if (c->flags) {
if (c->flags & CELL_ATTR_BOLD) {
PUT_PARAMETER(";1");
}
if (c->flags & CELL_ATTR_ITALIC) {
PUT_PARAMETER(";3");
}
uint32_t underline = c->flags & CELL_ATTR_UNDERLINE_MASK;
if (underline == CELL_ATTR_UNDERLINE_SINGLE) {
PUT_PARAMETER(";4");
} else if (underline == CELL_ATTR_UNDERLINE_DOUBLE) {
PUT_PARAMETER(";21");
} else if (underline == CELL_ATTR_UNDERLINE_CURLY) {
// TODO maybe filter this by terminal capability somewhere?
if (params.index + 2 >= params.max) {
int_puts(integration, "m\033[");
int_puts(integration, "4:3");
params.index = 2;
} else {
int_puts(integration, ";4:3");
params.index += 2;
}
}
if (c->flags & CELL_ATTR_BLINK) {
PUT_PARAMETER(";5");
}
if (c->flags & CELL_ATTR_OVERLINE) {
PUT_PARAMETER(";53");
}
if (c->flags & CELL_ATTR_INVERSE) {
PUT_PARAMETER(";7");
}
if (c->flags & CELL_ATTR_STRIKE) {
PUT_PARAMETER(";9");
}
}
int_puts(integration, "m");
#undef PUT_PARAMETER
current_bg = effective_bg_color;
current_fg = effective_fg_color;
current_deco = effective_deco_color;
current_flags = c->flags & CELL_ATTR_MASK;
if (current_patch_idx != c->attr_patch_idx) {
if (current_patch_idx) {
int_uputs(integration, surface->patches[current_patch_idx-1].cleanup);
}
if (c->attr_patch_idx) {
int_uputs(integration, surface->patches[c->attr_patch_idx-1].setup);
}
}
current_patch_idx = c->attr_patch_idx;
}
if (first_noncopy_space <= x) {
int_write(integration, "\033[K", 3);
pending_colum_move++;
speculation_buffer_state = -1;
cleared = true;
} else {
int_write(integration, (char*)text, code_units);
if (softwrap_prev != sw_no) {
softwrap_prev = sw_no;
if (term->did_terminal_disable_wrap) {
int_puts(integration, "\033[?7l");
}
}
if (softwrap == sw_double && x == surface->width - 1) {
// clear gap cell when a double width character causes wrap
int_write(integration, "\033[K", 3);
}
}
if (current_patch_idx) {
if (!surface->patches[c->attr_patch_idx-1].optimize) {
int_uputs(integration, surface->patches[c->attr_patch_idx-1].cleanup);
current_patch_idx = 0;
}
}
x += c->cluster_expansion;
}
if (current_patch_idx) {
int_uputs(integration, surface->patches[current_patch_idx-1].cleanup);
current_patch_idx = 0;
}
if (softwrap == sw_no) {
if (full_repaint) {
if (y+1 < surface->height) {
int_puts(integration, "\r\n");
}
} else {
pending_row_move += 1;
}
}
softwrap_prev = softwrap;
}
if (pending_row_move > 1) {
--pending_row_move; // don't move after paint rect
int_puts(integration, "\r");
if (pending_row_move < 4) {
while (pending_row_move) {
int_puts(integration, "\n");
--pending_row_move;
}
} else {
int_puts(integration, "\033[");
int_put_num(integration, pending_row_move);
int_puts(integration, "B");
}
}
if (term->cursor_x != -1 && term->cursor_y != -1) {
if (term->setup_state == SETUP_STATE_INLINE) {
term->inline_current_terminal_cursor_line = term->cursor_y;
int_puts(integration, "\r");
if (term->cursor_x) {
int_puts(integration, "\033[");
int_put_num(integration, term->cursor_x);
int_puts(integration, "C");
}
int move_up = surface->height - 1 - term->cursor_y;
if (move_up) {
int_puts(integration, "\033[");
int_put_num(integration, move_up);
int_puts(integration, "A");
}
} else {
termpaintp_terminal_set_cursor(term, term->cursor_x, term->cursor_y);
}
} else {
if (term->setup_state == SETUP_STATE_INLINE) {
term->inline_current_terminal_cursor_line = surface->height - 1;
}
if (pending_colum_move) {
int_puts(integration, "\033[");
if (pending_colum_move != 1) {
int_put_num(integration, pending_colum_move);
}
int_puts(integration, "C");
}
}
termpaintp_terminal_update_cursor_style(term);
if (term->cursor_visible) {
termpaintp_terminal_show_cursor(term);
}
if (term->colors_dirty) {
termpaint_color_entry *entry = term->colors_dirty;
term->colors_dirty = nullptr;
while (entry) {
termpaint_color_entry *next = entry->next_dirty;
entry->dirty = false;
entry->next_dirty = nullptr;
if (entry->requested.len) {
int_puts(integration, "\033]");
int_uputs(integration, entry->base.text);
int_puts(integration, ";");
int_uputs(integration, entry->requested.data);
int_puts(integration, termpaintp_terminal_correct_string_terminator(term));
} else {
int_uputs(integration, entry->restore.data);
}
entry = next;
}
}
int_puts(integration, "\033[m");
int_flush(integration);
}
void termpaint_terminal_flush(termpaint_terminal *term, bool full_repaint) {
termpaintp_terminal_flush_with_surface(term, full_repaint, &term->primary);
}
void termpaint_terminal_set_cursor_position(termpaint_terminal *term, int x, int y) {
if (x < 0 || y < 0) {
term->cursor_x = -1;
term->cursor_y = -1;
} else {
term->cursor_x = x;
term->cursor_y = y;
}
}
void termpaint_terminal_set_cursor_visible(termpaint_terminal *term, bool visible) {
term->cursor_visible = visible;
}
void termpaint_terminal_set_cursor_style(termpaint_terminal *term, int style, bool blink) {
switch (style) {
case TERMPAINT_CURSOR_STYLE_TERM_DEFAULT:
term->cursor_style = style;
term->cursor_blink = true;
break;
case TERMPAINT_CURSOR_STYLE_BLOCK:
case TERMPAINT_CURSOR_STYLE_UNDERLINE:
case TERMPAINT_CURSOR_STYLE_BAR:
term->cursor_style = style;
term->cursor_blink = blink;
break;
}
}
static void termpaintp_terminal_dirty_color_entry(termpaint_terminal *term, termpaint_color_entry *entry) {
if (!entry->dirty) {
entry->dirty = true;
entry->next_dirty = term->colors_dirty;
term->colors_dirty = entry;
}
}
bool termpaint_terminal_set_color_mustcheck(termpaint_terminal *term, int color_slot, int r, int g, int b) {
char buff_slot[30];
char buff_color[20];
sprintf(buff_slot, "%d", color_slot);
sprintf(buff_color, "#%02x%02x%02x", r & 0xff, g & 0xff, b & 0xff);
termpaint_color_entry *entry = termpaintp_hash_get(&term->colors, (uchar*)buff_slot);
if (!entry) {
termpaint_str prealloc_requested = { 0 };
termpaint_str prealloc_restore = { 0 };
if (!termpaintp_str_preallocate(&prealloc_restore, 32)) {
return false;
}
if (!termpaintp_str_preallocate(&prealloc_requested, 7)) {
termpaintp_str_destroy(&prealloc_restore);
return false;
}
entry = termpaintp_hash_ensure(&term->colors, (uchar*)buff_slot);
if (!entry) {
termpaintp_str_destroy(&prealloc_restore);
termpaintp_str_destroy(&prealloc_requested);
return false;
}
entry->restore = prealloc_restore; /*move ownership*/
entry->requested = prealloc_requested; /*move ownership*/
entry->save_state = termpaint_save_state_save_requested;
if (color_slot == TERMPAINT_COLOR_SLOT_CURSOR) {
// even requesting a color report does not allow to restore this, so just reset.
// terminals tend to internally store more than just color (e.g. an automatic mode) but can't report those
if (termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_7BIT_ST)) {
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)"\033]112\033\\");
} else {
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)"\033]112\a");
}
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
if (termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_7BIT_ST)) {
termpaintp_str_assign(&entry->restore, "\033]112\033\\");
} else {
termpaintp_str_assign(&entry->restore, "\033]112\a");
}
entry->save_state = termpaint_save_state_ready;
termpaintp_terminal_dirty_color_entry(term, entry);
} else {
termpaint_integration *integration = term->integration;
int_puts(integration, "\033]");
int_put_num(integration, color_slot);
if (termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_7BIT_ST)) {
int_puts(integration, ";?\033\\");
} else {
int_puts(integration, ";?\a");
}
int_awaiting_response(integration);
int_flush(integration);
}
}
if (entry->requested.len && ustrcmp(entry->requested.data, (uchar*)buff_color) == 0) {
return true;
}
if (entry->save_state == termpaint_save_state_ready) {
termpaintp_terminal_dirty_color_entry(term, entry);
} else if (entry->save_state == termpaint_save_state_save_requested) {
// nothing to do, color should be dirty already and color query event will trigger further processing.
}
termpaintp_str_assign(&entry->requested, buff_color);
return true;
}
void termpaint_terminal_set_color(termpaint_terminal *term, int color_slot, int r, int g, int b) {
if (!termpaint_terminal_set_color_mustcheck(term, color_slot, r, g, b)) {
termpaintp_oom(term);
}
}
void termpaint_terminal_reset_color(termpaint_terminal *term, int color_slot) {
char buff[100];
sprintf(buff, "%d", color_slot);
termpaint_color_entry *entry = termpaintp_hash_get(&term->colors, (uchar*)buff);
if (!entry) {
// not set, so no need to reset
return;
}
if (entry->save_state == termpaint_save_state_ready) {
termpaintp_terminal_dirty_color_entry(term, entry);
}
termpaintp_str_assign(&entry->requested, "");
}
static bool termpaintp_terminal_auto_detect_event(termpaint_terminal *terminal, termpaint_event *event);
static bool termpaintp_input_raw_filter_callback(void *user_data, const char *data, unsigned length, _Bool overflow) {
termpaint_terminal *term = user_data;
if (term->ad_state == AD_NONE || term->ad_state == AD_FINISHED) {
if (term->raw_input_filter_cb) {
return term->raw_input_filter_cb(term->raw_input_filter_user_data, data, length, overflow);
} else {
return false;
}
} else {
return false;
}
}
static int termpaintp_parse_delimited_uint(char *s, char delim) {
int res = 0;
for (; *s; s++) {
if (termpaintp_char_ascii_num(*s)) {
res = res * 10 + *s - '0';
} else if (*s == delim) {
return res;
} else {
return -1;
}
}
return -1;
}
static int termpaintp_parse_version(char *s) {
int res = 0;
int place = 0;
int tmp = 0;
for (; *s; s++) {
if (termpaintp_char_ascii_num(*s)) {
tmp = tmp * 10 + *s - '0';
} else if (*s == '.') {
if (tmp >= 1000) {
tmp = 999;
}
if (place == 0) {
res += tmp * 1000000;
} else if (place == 1) {
res += tmp * 1000;
} else if (place == 2) {
break;
}
tmp = 0;
++place;
} else {
break;
}
}
if (tmp >= 1000) {
tmp = 999;
}
if (place == 0) {
res += tmp * 1000000;
} else if (place == 1) {
res += tmp * 1000;
} else if (place == 2) {
res += tmp;
return res;
}
return res;
}
static int termpaintp_parse_version_strict(char *s, int placeMul) {
int res = 0;
int place = 0;
int tmp = 0;
for (; *s; s++) {
if (termpaintp_char_ascii_num(*s)) {
tmp = tmp * 10 + *s - '0';
} else if (*s == '.') {
if (tmp >= placeMul) {
tmp = placeMul - 1;
}
if (place == 0) {
res += tmp * placeMul * placeMul;
} else if (place == 1) {
res += tmp * placeMul;
} else if (place == 2) {
break;
}
tmp = 0;
++place;
} else {
tmp = 0;
break;
}
}
if (tmp >= placeMul) {
tmp = placeMul - 1;
}
if (place == 0) {
res += tmp * placeMul * placeMul;
} else if (place == 1) {
res += tmp * placeMul;
} else if (place == 2) {
res += tmp;
return res;
}
return res;
}
static void termpaintp_auto_detect_init_terminal_version_and_caps(termpaint_terminal *term) {
if (termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_CSI_GREATER)) {
// use TERMPAINT_CAPABILITY_CSI_GREATER as indication for more advanced parsing capabilities,
// as there is no dedicated detection for this.
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_CSI_POSTFIX_MOD);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE);
}
if (term->terminal_type == TT_MISPARSING) {
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_EXTENDED_CHARSET);
} else if (term->terminal_type == TT_TOODUMB) {
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_EXTENDED_CHARSET);
} else if (term->terminal_type == TT_BASE) {
if (!term->auto_detect_sec_device_attributes.len) {
// This is primarily because of linux vc, see somment in TT_LINUX for details.
// It's fairly easy for other terminals to work around by implementing ESC [ >c or ESC [ =c
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_EXTENDED_CHARSET);
}
} else if (term->terminal_type == TT_VTE) {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
int version = 0;
if (term->terminal_self_reported_name_version.len) {
char *version_part = strchr((const char*)term->terminal_self_reported_name_version.data, '(');
if (version_part) {
int tmp = termpaintp_parse_delimited_uint(version_part + 1, ')');
if (tmp > 0) {
version = tmp;
term->terminal_version = version;
}
}
}
if (!version && term->auto_detect_sec_device_attributes.len > 11) {
const unsigned char* data = term->auto_detect_sec_device_attributes.data;
bool vte_gt0_54 = memcmp(data, "\033[>65;", 6) == 0;
bool vte_old = memcmp(data, "\033[>1;", 5) == 0;
if (vte_gt0_54 || vte_old) {
if (vte_old) {
data += 5;
} else {
data += 6;
}
while (termpaintp_char_ascii_num(*data)) {
version = version * 10 + *data - '0';
++data;
}
if (*data == ';' && (version < 5400) == vte_old) {
term->terminal_version = version;
}
}
}
if (term->terminal_version < 4000) {
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE);
} else {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE);
}
if (term->terminal_version >= 5400) {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TITLE_RESTORE);
}
if (term->terminal_version < 5400) {
// fragile dictinary base parsing.
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_CSI_GREATER);
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_CSI_EQUALS);
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_CSI_POSTFIX_MOD);
}
if (term->terminal_version < 3600) {
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED);
} else {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
}
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_CLEARED_COLORING_DEFCOLOR);
} else if (term->terminal_type == TT_XTERM) {
if (term->auto_detect_sec_device_attributes.len > 10) {
const unsigned char* data = term->auto_detect_sec_device_attributes.data;
while (*data != ';' && *data != 0) {
++data;
}
if (*data == ';') {
++data;
int version = 0;
while (termpaintp_char_ascii_num(*data)) {
version = version * 10 + *data - '0';
++data;
}
if (*data == ';') {
term->terminal_version = version;
if (term->terminal_version < 282) {
// xterm < 282 does not support BAR style. Enable remapping.
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE_BAR);
}
}
}
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TITLE_RESTORE);
if (term->terminal_version < 282) {
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED);
} else {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
}
// tab is converted to space by the default settings starting from version 333.
// But that's true regardless of state of bracketed paste.
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
} else if (term->terminal_type == TT_SCREEN) {
const unsigned char* data = term->auto_detect_sec_device_attributes.data;
if (term->auto_detect_sec_device_attributes.len > 10 && memcmp(data, "\033[>83;", 6) == 0) {
data += 6;
int version = 0;
while (termpaintp_char_ascii_num(*data)) {
version = version * 10 + *data - '0';
++data;
}
if (*data == ';') {
term->terminal_version = version;
}
}
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED);
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_CLEARED_COLORING);
} else if (term->terminal_type == TT_TMUX) {
if (term->terminal_self_reported_name_version.len) {
char *version_part = strchr((const char*)term->terminal_self_reported_name_version.data, ' ');
if (version_part) {
term->terminal_version = termpaintp_parse_version(version_part + 1);
}
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
} else if (term->terminal_type == TT_KONSOLE) {
if (term->terminal_type_confidence == 2) {
// this is set by 3RD_DEV_ATTRIB, which was introduced in version 22.03.70
term->terminal_version = 220370;
}
if (term->terminal_self_reported_name_version.len) {
char *version_part = strchr((const char*)term->terminal_self_reported_name_version.data, ' ');
if (version_part) {
term->terminal_version = termpaintp_parse_version_strict(version_part + 1, 100);
}
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
// konsole starting at version 18.07.70 could do the CSI space q one too, but
// we don't have the konsole version.
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_CURSOR_SHAPE_OSC50);
if (term->terminal_version < 220370) {
// konsole starting at version 19.08.2 supports 7-bit ST, but
// we don't have a fine konsole version.
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_7BIT_ST);
// konsole maps some ordinary non spacing characters to width 1, unbreak output by using a specific width table.
term->char_width_table = &termpaintp_char_width_konsole2018;
} else {
term->char_width_table = &termpaintp_char_width_konsole2022;
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
} else if (term->terminal_type == TT_URXVT) {
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED);
// XXX: urxvt 9.19 seems to crash on bracketed paste, so don't set it
// at least till 9.22 urxvt sends just ESC as terminator in replies when using ESC \ in the request.
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_7BIT_ST);
} else if (term->terminal_type == TT_LINUXVC) {
// Linux VC has to fit all character choices into 8 bit or 9 bit (depending on config)
// thus is has a very limited set of characters available. What is available exactly
// depends on the font, with most fonts optimizing for a given set of languages and
// only providing a small set of line drawing characters etc.
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_EXTENDED_CHARSET);
} else if (term->terminal_type == TT_MACOS) {
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED);
// does background color erase (bce) but does not allow multiple colors of cleared cells
termpaint_terminal_disable_capability(term, TERMPAINT_CAPABILITY_CLEARED_COLORING);
} else if (term->terminal_type == TT_TERMINOLOGY) {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
// To get here terminology has to be at least 1.4 (first version to support DA3)
if (term->terminal_self_reported_name_version.len) {
char *version_part = strchr((const char*)term->terminal_self_reported_name_version.data, ' ');
if (version_part) {
term->terminal_version = termpaintp_parse_version(version_part + 1);
}
}
// terminology approximates to 256 color palette internally (since 1.2.0), but that's ok.
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
if (term->terminal_version >= 1007000) { // supported since 1.7.0
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TITLE_RESTORE);
}
// all shapes have been added in 1.2 so this is always safe.
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE_BAR);
} else if (term->terminal_type == TT_MINTTY) {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
const unsigned char* data = term->auto_detect_sec_device_attributes.data;
if (term->auto_detect_sec_device_attributes.len > 10 && memcmp(data, "\033[>77;", 6) == 0) {
data += 6;
int version = 0;
while (termpaintp_char_ascii_num(*data)) {
version = version * 10 + *data - '0';
++data;
}
if (*data == ';') {
term->terminal_version = version;
}
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TITLE_RESTORE);
} else if (term->terminal_type == TT_KITTY) {
if (term->auto_detect_sec_device_attributes.len > 5
&& termpaintp_string_prefix((const uchar*)"\033[>1;", term->auto_detect_sec_device_attributes.data, term->auto_detect_sec_device_attributes.len)) {
int val = 0;
for (const unsigned char *tmp = term->auto_detect_sec_device_attributes.data + 5; *tmp; tmp++) {
if (termpaintp_char_ascii_num(*tmp)) {
val = val * 10 + (*tmp - '0');
} else if (*tmp == ';') {
if (val >= 4000) {
int version = (val - 4000 ) * 1000;
val = 0;
tmp++;
for (; *tmp; tmp++) {
if (termpaintp_char_ascii_num(*tmp)) {
val = val * 10 + (*tmp - '0');
} else if (*tmp == ';' || *tmp == 'c') {
if (val < 1000) {
version += val;
} else {
version += 999;
}
term->terminal_version = version;
} else {
break;
}
}
}
break;
} else {
break;
}
}
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TITLE_RESTORE);
} else if (term->terminal_type == TT_ITERM2) {
if (term->terminal_self_reported_name_version.len) {
char *version_part = strchr((const char*)term->terminal_self_reported_name_version.data, ' ');
if (version_part) {
term->terminal_version = termpaintp_parse_version_strict(version_part + 1, 1000);
}
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
} else if (term->terminal_type == TT_MLTERM) {
if (term->terminal_self_reported_name_version.len) {
char *version_part = strchr((const char*)term->terminal_self_reported_name_version.data, '(');
if (version_part) {
term->terminal_version = termpaintp_parse_version(version_part + 1);
}
}
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
term->max_csi_parameters = 10;
} else if (term->terminal_type == TT_MSFT_TERMINAL) {
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
} else if (term->terminal_type == TT_FULL) {
// full is promised to claim support for everything
// But TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT, TERMPAINT_CAPABILITY_CSI_GREATER
// and TERMPAINT_CAPABILITY_CSI_EQUALS are detected in main finger printing.
// 88_COLOR disables 256 color support and is quite rxvt-unicode specific
// CURSOR_SHAPE_OSC50 is konsole (and derived) specific, general terminals are expected to use
// the ESC[ VAL SP q sequence for cursor shape and blink setup.
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TITLE_RESTORE);
termpaint_terminal_promise_capability(term, TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED);
}
}
void termpaint_terminal_auto_detect_apply_input_quirks(termpaint_terminal *terminal, bool backspace_is_x08) {
// For now apply backspace_is_x08 for all terminal types. This can be tuned to disregard this for
// specific types when needed.
// Note: terminology does not support ctrl-backspace in backspace_is_x08 mode, but does when !backspace_is_x08.
// so it seems swapped is still a ok mapping.
if (backspace_is_x08) {
termpaint_input_activate_quirk(terminal->input, TERMPAINT_INPUT_QUIRK_BACKSPACE_X08_AND_X7F_SWAPPED);
}
if (terminal->terminal_type == TT_MINTTY) {
termpaint_input_activate_quirk(terminal->input, TERMPAINT_INPUT_QUIRK_C1_FOR_CTRL_SHIFT);
}
}
static void termpaintp_input_event_callback(void *user_data, termpaint_event *event) {
termpaint_terminal *term = user_data;
if (term->ad_state == AD_NONE || term->ad_state == AD_FINISHED) {
if (event->type == TERMPAINT_EV_COLOR_SLOT_REPORT) {
char buff[100];
sprintf(buff, "%d", event->color_slot_report.slot);
termpaint_color_entry *entry = termpaintp_hash_ensure(&term->colors, (uchar*)buff);
if (entry) { // entry may be nullptr if not requested via termpaint and out of memory
if (entry->save_state == termpaint_save_state_save_requested
|| entry->save_state == termpaint_save_state_new_entry) {
entry->save_state = termpaint_save_state_ready;
termpaintp_str_assign(&entry->restore, "\033]");
termpaintp_str_append(&entry->restore, (const char*)entry->base.text);
termpaintp_str_append(&entry->restore, ";");
termpaintp_str_append_n(&entry->restore, event->color_slot_report.color, event->color_slot_report.length);
termpaintp_str_append(&entry->restore, termpaintp_terminal_correct_string_terminator(term));
termpaintp_prepend_str(&term->restore_seq_partial, entry->restore.data);
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
if (entry->requested.len && !entry->dirty) {
term->request_repaint = true;
termpaintp_terminal_dirty_color_entry(term, entry);
}
}
}
}
term->event_cb(term->event_user_data, event);
} else {
termpaintp_terminal_auto_detect_event(term, event);
int_flush(term->integration);
if (term->ad_state == AD_FINISHED) {
termpaintp_auto_detect_init_terminal_version_and_caps(term);
if (term->event_cb) {
termpaint_event event;
event.type = TERMPAINT_EV_AUTO_DETECT_FINISHED;
term->event_cb(term->event_user_data, &event);
}
}
}
}
void termpaint_terminal_callback(termpaint_terminal *term) {
if (term->data_pending_after_input_received) {
term->data_pending_after_input_received = false;
termpaint_integration *integration = term->integration;
int_puts(integration, "\033[5n");
int_awaiting_response(integration);
int_flush(integration);
}
}
void termpaint_terminal_set_raw_input_filter_cb(termpaint_terminal *term, bool (*cb)(void *, const char *, unsigned, bool), void *user_data) {
term->raw_input_filter_cb = cb;
term->raw_input_filter_user_data = user_data;
}
void termpaint_terminal_set_event_cb(termpaint_terminal *term, void (*cb)(void *, termpaint_event *), void *user_data) {
term->event_cb = cb;
term->event_user_data = user_data;
}
void termpaint_terminal_add_input_data(termpaint_terminal *term, const char *data, unsigned length) {
if (term->log_mask & TERMPAINT_LOG_TRACE_RAW_INPUT) {
int_debuglog_puts(term, "Input: ");
for (unsigned i = 0; i < length; i++) {
int_debuglog_printf(term, "%.2hhx", (unsigned char)data[i]);
}
int_debuglog_puts(term, "\n");
}
termpaint_input_add_data(term->input, data, length);
bool not_in_autodetect = (term->ad_state == AD_NONE || term->ad_state == AD_FINISHED);
if (not_in_autodetect && term->request_repaint) {
termpaint_event event;
event.type = TERMPAINT_EV_REPAINT_REQUESTED;
term->event_cb(term->event_user_data, &event);
term->request_repaint = false;
}
if (not_in_autodetect && termpaint_input_peek_buffer_length(term->input)) {
term->data_pending_after_input_received = true;
if (term->integration_vtbl->request_callback) {
term->integration_vtbl->request_callback(term->integration);
} else {
termpaint_terminal_callback(term);
}
} else {
term->data_pending_after_input_received = false;
}
}
const char *termpaint_terminal_peek_input_buffer(const termpaint_terminal *term) {
return termpaint_input_peek_buffer(term->input);
}
int termpaint_terminal_peek_input_buffer_length(const termpaint_terminal *term) {
return termpaint_input_peek_buffer_length(term->input);
}
void termpaint_terminal_expect_cursor_position_report(termpaint_terminal *term) {
termpaint_input_expect_cursor_position_report(term->input);
}
void termpaint_terminal_expect_legacy_mouse_reports(termpaint_terminal *term, int s) {
termpaint_input_expect_legacy_mouse_reports(term->input, s);
}
void termpaint_terminal_handle_paste(termpaint_terminal *term, bool enabled) {
termpaint_input_handle_paste(term->input, enabled);
}
void termpaint_terminal_expect_apc_input_sequences(termpaint_terminal *term, bool enabled) {
termpaint_input_expect_apc_sequences(term->input, enabled);
}
void termpaint_terminal_activate_input_quirk(termpaint_terminal *term, int quirk) {
termpaint_input_activate_quirk(term->input, quirk);
}
static void termpaintp_patch_misparsing_defered(termpaint_terminal *terminal, termpaint_integration *integration,
auto_detect_state next_state) {
terminal->ad_state = AD_GLITCH_PATCHING;
terminal->glitch_patching_next_state = next_state;
int reset_x = terminal->initial_cursor_x;
int reset_y = terminal->initial_cursor_y;
if ((terminal->initial_cursor_y == terminal->glitch_cursor_y) && (terminal->initial_cursor_x > terminal->glitch_cursor_x)) {
// when starting on the last line a line wrap caused by glitches will scroll and thus the cursor seemingly
// just moves left on the same line. Gliches start on the line that has scrolled up when wraping thus start on
// that line
reset_y -= 1;
}
int_puts(integration, "\033[");
int_put_num(integration, reset_y + 1);
int_puts(integration, ";");
int_put_num(integration, reset_x + 1);
int_puts(integration, "H");
int_puts(integration, " ");
if (termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT)) {
int_puts(integration, "\033[?6n");
} else {
int_puts(integration, "\033[6n");
termpaint_terminal_expect_cursor_position_report(terminal);
}
}
static void termpaintp_patch_misparsing_from_event(termpaint_terminal *terminal, termpaint_integration *integration,
termpaint_event *event, auto_detect_state next_state) {
terminal->glitch_cursor_x = event->cursor_position.x;
terminal->glitch_cursor_y = event->cursor_position.y;
termpaintp_patch_misparsing_defered(terminal, integration, next_state);
}
static void termpaintp_terminal_auto_detect_prepare_self_reporting(termpaint_terminal *terminal, int new_state) {
termpaint_integration *integration = terminal->integration;
int_puts(integration, "\033[>q");
bool might_be_kitty = false;
bool might_be_iterm2 = false;
bool might_be_mlterm = false;
if (terminal->auto_detect_sec_device_attributes.len) {
const int attr_len = terminal->auto_detect_sec_device_attributes.len;
if (termpaintp_string_prefix((const uchar*)"\033[>1;", terminal->auto_detect_sec_device_attributes.data, attr_len)) {
int val = 0;
for (const unsigned char *tmp = terminal->auto_detect_sec_device_attributes.data + 5; *tmp; tmp++) {
if (termpaintp_char_ascii_num(*tmp)) {
val = val * 10 + (*tmp - '0');
} else if (*tmp == ';') {
if (val >= 4000) {
might_be_kitty = true;
}
break;
} else {
break;
}
}
}
might_be_iterm2 = (!terminal->seen_dec_terminal_param
&& attr_len == 10
&& memcmp(terminal->auto_detect_sec_device_attributes.data, "\033[>0;95;0c", 10) == 0);
might_be_mlterm = (terminal->seen_dec_terminal_param
&& attr_len == 12
&& memcmp(terminal->auto_detect_sec_device_attributes.data, "\033[>24;279;0c", 10) == 0);
}
if (might_be_kitty || might_be_iterm2 || might_be_mlterm) {
int_puts(integration, "\033P+q544e\033\\");
}
int_puts(integration, "\033[5n");
int_awaiting_response(integration);
terminal->ad_state = new_state;
}
// known terminals where auto detections hangs: freebsd system console using vt module
static bool termpaintp_terminal_auto_detect_event(termpaint_terminal *terminal, termpaint_event *event) {
termpaint_integration *integration = terminal->integration;
if (event == nullptr) {
terminal->ad_state = AD_INITIAL;
}
if (terminal->log_mask & TERMPAINT_LOG_AUTO_DETECT_TRACE) {
if (event) {
int_debuglog_printf(terminal, "AD: State=%d, Event-type=%d\n", terminal->ad_state, event->type);
} else {
int_debuglog_printf(terminal, "AD start: State=%d\n", terminal->ad_state);
}
}
switch (terminal->ad_state) {
case AD_NONE:
case AD_FINISHED:
// should not happen
break;
case AD_INITIAL:
terminal->glitch_cursor_y = -1; // disarmed glitch patching state
termpaint_input_expect_cursor_position_report(terminal->input);
termpaint_input_expect_cursor_position_report(terminal->input);
int_puts(integration, "\033[5n");
int_puts(integration, "\033[6n");
int_puts(integration, "\033[>c");
int_puts(integration, "\033[6n");
int_puts(integration, "\033[5n");
int_awaiting_response(integration);
terminal->ad_state = AD_BASICCOMPAT;
return true;
case AD_BASICCOMPAT:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
terminal->ad_state = AD_BASIC_REQ;
return true;
} else if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
terminal->initial_cursor_x = event->cursor_position.x;
terminal->initial_cursor_y = event->cursor_position.y;
terminal->terminal_type = TT_INCOMPATIBLE;
terminal->ad_state = AD_BASIC_REQ_FAILED_CURPOS_RECVED;
return true;
} else if (event->type == TERMPAINT_EV_CHAR && event->c.length == 1
&& event->c.string[0] == '0' && event->c.modifier == TERMPAINT_MOD_ALT) {
// hterm has a long standing typo in it's \033[5n reply that replys with a missing '['
terminal->terminal_type = TT_INCOMPATIBLE;
terminal->ad_state = AD_HTERM_RECOVERY1;
return true;
} else if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
terminal->terminal_type = TT_TOODUMB;
terminal->ad_state = AD_FINISHED;
return false;
}
break;
case AD_BASIC_REQ_FAILED_CURPOS_RECVED:
if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
terminal->ad_state = AD_FINISHED;
return false;
} else if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
// no use, but still need to wait for cursor report reply
terminal->ad_state = AD_BASIC_REQ_FAILED_CURPOS_RECVED;
return true;
}
break;
case AD_BASIC_REQ:
if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
terminal->initial_cursor_x = event->cursor_position.x;
terminal->initial_cursor_y = event->cursor_position.y;
terminal->ad_state = AD_BASIC_CURPOS_RECVED;
return true;
} else if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
terminal->terminal_type = TT_TOODUMB;
terminal->ad_state = AD_EXPECT_SYNC_TO_FINISH;
return true;
} else if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
terminal->terminal_type = TT_TOODUMB;
terminal->ad_state = AD_FINISHED;
return false;
}
break;
case AD_BASIC_CURPOS_RECVED:
if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_GREATER);
termpaintp_str_assign_n(&terminal->auto_detect_sec_device_attributes, event->raw.string, event->raw.length);
if (event->raw.length > 6 && memcmp("\033[>85;", event->raw.string, 6) == 0) {
// urxvt source says: first parameter is 'U' / 85 for urxvt (except for 7.[34])
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
terminal->terminal_type = TT_URXVT;
terminal->terminal_type_confidence = 2;
}
if (event->raw.length > 6 && memcmp("\033[>83;", event->raw.string, 6) == 0) {
// 83 = 'S'
// second parameter is version as major*10000 + minor * 100 + patch
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
terminal->terminal_type = TT_SCREEN;
terminal->terminal_type_confidence = 2;
}
if (event->raw.length > 6 && memcmp("\033[>84;", event->raw.string, 6) == 0) {
// 84 = 'T'
// no version here
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
terminal->terminal_type = TT_TMUX;
terminal->terminal_type_confidence = 2;
}
if (event->raw.length > 6 && memcmp("\033[>77;", event->raw.string, 6) == 0) {
// 77 = 'M'
// second parameter is version as major*10000 + minor * 100 + patch
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
terminal->terminal_type = TT_MINTTY;
terminal->terminal_type_confidence = 2;
}
terminal->ad_state = AD_BASIC_SEC_DEV_ATTRIB_RECVED_CONSUME_CURPOS;
return true;
} else if (event->type == TERMPAINT_EV_RAW_PRI_DEV_ATTRIB) {
// We never asked for primary device attributes. This means the terminal gets
// basic parsing rules wrong.
terminal->terminal_type = TT_TOODUMB;
terminal->ad_state = AD_WAIT_FOR_SYNC_TO_FINISH;
return true;
} else if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
// check if finger printing left printed characters
if (terminal->initial_cursor_x == event->cursor_position.x
&& terminal->initial_cursor_y == event->cursor_position.y) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_GREATER);
terminal->ad_state = AD_BASIC_CURPOS_RECVED_NO_SEC_DEV_ATTRIB;
return true;
} else {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_CSI_GREATER);
terminal->terminal_type = TT_MISPARSING;
// prepare defered glitch patching
terminal->glitch_cursor_x = event->cursor_position.x;
terminal->glitch_cursor_y = event->cursor_position.y;
terminal->ad_state = AD_BASIC_NO_SEC_DEV_ATTRIB_MISPARSING;
return true;
}
}
break;
case AD_BASIC_NO_SEC_DEV_ATTRIB_MISPARSING:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaintp_patch_misparsing_defered(terminal, integration, AD_FINISHED);
return true;
}
break;
case AD_BASIC_CURPOS_RECVED_NO_SEC_DEV_ATTRIB:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_GREATER);
int_puts(integration, "\033[=c");
int_puts(integration, "\033[>1c");
int_puts(integration, "\033[?6n");
int_puts(integration, "\033[1x");
int_puts(integration, "\033[5n");
int_awaiting_response(integration);
terminal->ad_state = AD_FP1_REQ;
return true;
}
break;
case AD_BASIC_SEC_DEV_ATTRIB_RECVED_CONSUME_CURPOS:
if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
terminal->ad_state = AD_BASIC_SEC_DEV_ATTRIB_RECVED;
return true;
}
break;
case AD_BASIC_SEC_DEV_ATTRIB_RECVED:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
if (terminal->terminal_type_confidence >= 2) {
if (terminal->terminal_type == TT_URXVT) {
// auto detect 88 or 256 color mode by observing if querying color 255 results in a response
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_88_COLOR);
// Using BEL as termination, because urxvt doesn't properly support ESC \ as terminator
// at least till 9.22 urxvt sends just ESC as terminator when using ESC \ in the request.
int_puts(integration, "\033]4;255;?\007");
int_puts(integration, "\033[5n");
terminal->ad_state = AD_URXVT_88_256_REQ;
return true;
} else {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
}
}
int_puts(integration, "\033[=c");
int_puts(integration, "\033[>1c");
int_puts(integration, "\033[?6n");
int_puts(integration, "\033[1x");
int_puts(integration, "\033[5n");
int_awaiting_response(integration);
terminal->ad_state = AD_FP1_REQ;
return true;
}
break;
case AD_URXVT_88_256_REQ:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
} else if (event->type == TERMPAINT_EV_PALETTE_COLOR_REPORT) {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_88_COLOR);
return true;
}
break;
case AD_FP1_REQ:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
if (terminal->terminal_type_confidence == 0) {
terminal->terminal_type = TT_BASE;
}
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
// see if "\033[=c" was misparsed
termpaint_input_expect_cursor_position_report(terminal->input);
int_puts(integration, "\033[6n");
int_awaiting_response(integration);
terminal->ad_state = AD_FP1_CLEANUP;
return true;
} else if (event->type == TERMPAINT_EV_RAW_3RD_DEV_ATTRIB) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
if (event->raw.length == 8) {
// Terminal implementors: DO NOT fake other terminal IDs here!
// any unknown id will enable all features here. Allocate a new one!
if (memcmp(event->raw.string, "7E565445", 8) == 0) { // ~VTE
terminal->terminal_type = TT_VTE;
terminal->terminal_type_confidence = 2;
} else if (memcmp(event->raw.string, "7E7E5459", 8) == 0) { // ~~TY
terminal->terminal_type = TT_TERMINOLOGY;
terminal->terminal_type_confidence = 2;
} else if (memcmp(event->raw.string, "7E4B4445", 8) == 0) { // ~KDE
terminal->terminal_type = TT_KONSOLE;
terminal->terminal_type_confidence = 2;
} else if (memcmp(event->raw.string, "7E4C4E58", 8) == 0) { // ~LNX
terminal->terminal_type = TT_LINUXVC;
terminal->terminal_type_confidence = 2;
} else if (memcmp(event->raw.string, "00000000", 8) == 0) {
// xterm uses this since 336. But this could be something else too.
// Microsoft Terminal uses this as well.
terminal->terminal_type = TT_BASE;
if (terminal->auto_detect_sec_device_attributes.len
&& ustr_eq(terminal->auto_detect_sec_device_attributes.data, (const uchar*)"\033[>0;10;1c")) {
terminal->terminal_type = TT_MSFT_TERMINAL;
terminal->terminal_type_confidence = 1;
} else {
if (terminal->auto_detect_sec_device_attributes.len > 10) {
const unsigned char* data = terminal->auto_detect_sec_device_attributes.data;
while (*data != ';' && *data != 0) {
++data;
}
if (*data == ';') {
++data;
int version = 0;
while (termpaintp_char_ascii_num(*data)) {
version = version * 10 + *data - '0';
++data;
}
if (*data == ';') {
if (version >= 336) {
terminal->terminal_type = TT_XTERM;
terminal->terminal_type_confidence = 1;
}
}
}
}
}
} else {
terminal->terminal_type = TT_FULL;
terminal->terminal_type_confidence = 1;
}
terminal->ad_state = AD_FP1_REQ_TERMID_RECVED;
} else if (event->raw.length == 1 && event->raw.string[0] == '0') {
// xterm uses this between 280 and 335. But this could be something else too.
if (terminal->auto_detect_sec_device_attributes.len == 12
&& memcmp(terminal->auto_detect_sec_device_attributes.data, "\033[>41;", 6) == 0
&& termpaintp_char_ascii_num(terminal->auto_detect_sec_device_attributes.data[6])
&& termpaintp_char_ascii_num(terminal->auto_detect_sec_device_attributes.data[7])
&& termpaintp_char_ascii_num(terminal->auto_detect_sec_device_attributes.data[8])
&& memcmp(terminal->auto_detect_sec_device_attributes.data + 9, ";0c", 3) == 0) {
int version = (terminal->auto_detect_sec_device_attributes.data[6] - '0') * 100
+ (terminal->auto_detect_sec_device_attributes.data[7] - '0') * 10
+ terminal->auto_detect_sec_device_attributes.data[8] - '0';
if (280 <= version && version <= 335) {
terminal->terminal_type = TT_XTERM;
terminal->terminal_type_confidence = 1;
terminal->ad_state = AD_FP1_REQ_TERMID_RECVED;
}
}
}
return true;
} else if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
terminal->ad_state = AD_FP1_SEC_DEV_ATTRIB_RECVED;
return true;
} else if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
if (event->cursor_position.safe) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
} else {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
}
if (terminal->initial_cursor_y != event->cursor_position.y
|| terminal->initial_cursor_x != event->cursor_position.x) {
// prepare defered glitch patching
terminal->glitch_cursor_x = event->cursor_position.x;
terminal->glitch_cursor_y = event->cursor_position.y;
terminal->terminal_type = TT_BASE;
} else {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
terminal->terminal_type = TT_BASE;
}
terminal->ad_state = AD_FP1_QMCURSOR_POS_RECVED;
return true;
} else if (event->type == TERMPAINT_EV_RAW_DECREQTPARM) {
terminal->seen_dec_terminal_param = true;
if (terminal->terminal_type_confidence == 0) {
terminal->terminal_type = TT_BASE;
}
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
terminal->ad_state = AD_FP1_CLEANUP_AFTER_SYNC;
return true;
} else if (event->type == TERMPAINT_EV_RAW_PRI_DEV_ATTRIB) {
// For terminals that misinterpret \033[=c as \033[c
terminal->ad_state = AD_FP1_3RD_DEV_ATTRIB_ALIASED_TO_PRI;
return true;
}
break;
case AD_FP1_3RD_DEV_ATTRIB_ALIASED_TO_PRI:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
terminal->terminal_type = TT_BASE;
terminal->ad_state = AD_FINISHED;
return false;
} else if (event->type == TERMPAINT_EV_RAW_DECREQTPARM) {
terminal->seen_dec_terminal_param = true;
terminal->terminal_type = TT_MACOS;
terminal->ad_state = AD_EXPECT_SYNC_TO_FINISH;
return true;
} else {
terminal->terminal_type = TT_BASE;
terminal->ad_state = AD_WAIT_FOR_SYNC_TO_FINISH;
return true;
}
break;
case AD_FP1_CLEANUP:
if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
if (terminal->initial_cursor_y != event->cursor_position.y
|| terminal->initial_cursor_x != event->cursor_position.x) {
termpaintp_patch_misparsing_from_event(terminal, integration, event, AD_FINISHED);
return true;
} else {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
}
}
break;
case AD_EXPECT_SYNC_TO_FINISH:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
terminal->ad_state = AD_FINISHED;
return false;
}
break;
case AD_FP1_CLEANUP_AFTER_SYNC:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
// see if "\033[=c" was misparsed
if (termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT)) {
int_puts(integration, "\033[?6n");
} else {
termpaint_input_expect_cursor_position_report(terminal->input);
int_puts(integration, "\033[6n");
}
int_awaiting_response(integration);
terminal->ad_state = AD_FP1_CLEANUP;
return true;
}
break;
case AD_WAIT_FOR_SYNC_TO_SELF_REPORTING:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
} else {
if (event->type != TERMPAINT_EV_KEY && event->type != TERMPAINT_EV_CHAR) {
return true;
}
}
break;
case AD_EXPECT_SYNC_TO_SELF_REPORTING:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
}
break;
case AD_SELF_REPORTING:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
terminal->ad_state = AD_FINISHED;
return false;
} else if (event->type == TERMPAINT_EV_RAW_TERM_NAME) {
terminal->ad_state = AD_SELF_REPORTING;
termpaintp_str_assign_n(&terminal->terminal_self_reported_name_version, event->raw.string, event->raw.length);
if (termpaintp_string_prefix((const uchar*)"terminology ", (const uchar*)event->raw.string, event->raw.length)) {
terminal->terminal_type = TT_TERMINOLOGY;
}
if (termpaintp_string_prefix((const uchar*)"iTerm2 ", (const uchar*)event->raw.string, event->raw.length)) {
terminal->terminal_type = TT_ITERM2;
}
if (termpaintp_string_prefix((const uchar*)"VTE(", (const uchar*)event->raw.string, event->raw.length)) {
terminal->terminal_type = TT_VTE;
}
return true;
} else if (event->type == TERMPAINT_EV_RAW_TERMINFO_QUERY_REPLY) {
terminal->ad_state = AD_SELF_REPORTING;
if (event->raw.length >= 8 && event->raw.string[0] == '1') { // only successful/valid reports
if (termpaintp_mem_ascii_case_insensitive_equals(event->raw.string + 3, "544e=", 5)) {
if (event->raw.length == 30
&& termpaintp_mem_ascii_case_insensitive_equals(event->raw.string + 8, "787465726d2d6b69747479", 22)) {
terminal->terminal_type = TT_KITTY;
}
if (event->raw.length == 20
&& termpaintp_mem_ascii_case_insensitive_equals(event->raw.string + 8, "695465726d32", 12)) {
terminal->terminal_type = TT_ITERM2;
}
if (event->raw.length == 20
&& termpaintp_mem_ascii_case_insensitive_equals(event->raw.string + 8, "6D6C7465726D", 12)) {
terminal->terminal_type = TT_MLTERM;
}
}
}
return true;
}
break;
case AD_WAIT_FOR_SYNC_TO_FINISH:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
terminal->ad_state = AD_FINISHED;
return false;
} else {
if (event->type != TERMPAINT_EV_KEY && event->type != TERMPAINT_EV_CHAR) {
return true;
}
}
break;
case AD_FP1_REQ_TERMID_RECVED:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
} else if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
terminal->ad_state = AD_FP1_REQ_TERMID_RECVED_SEC_DEV_ATTRIB_RECVED;
return true;
} else if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
// keep terminal_type from terminal id
if (event->cursor_position.safe) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
} else {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
}
terminal->ad_state = AD_WAIT_FOR_SYNC_TO_SELF_REPORTING;
return true;
} else if (event->type == TERMPAINT_EV_RAW_DECREQTPARM) {
terminal->seen_dec_terminal_param = true;
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
terminal->ad_state = AD_EXPECT_SYNC_TO_SELF_REPORTING;
return true;
}
break;
case AD_FP1_REQ_TERMID_RECVED_SEC_DEV_ATTRIB_RECVED:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
} else if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
if (event->cursor_position.safe) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
} else {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
}
terminal->ad_state = AD_WAIT_FOR_SYNC_TO_SELF_REPORTING;
return true;
} else if (event->type == TERMPAINT_EV_RAW_DECREQTPARM) {
terminal->seen_dec_terminal_param = true;
// ignore
return true;
}
break;
case AD_FP1_SEC_DEV_ATTRIB_RECVED:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
termpaint_input_expect_cursor_position_report(terminal->input);
int_puts(integration, "\033[6n"); // detect if "\033[=c" was misparsed
int_puts(integration, "\033[>0;1c");
int_puts(integration, "\033[5n");
int_awaiting_response(integration);
terminal->ad_state = AD_FP2_REQ;
return true;
} else if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
if (event->cursor_position.safe) {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
} else {
termpaint_terminal_disable_capability(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT);
}
if (terminal->initial_cursor_y != event->cursor_position.y
|| terminal->initial_cursor_x != event->cursor_position.x) {
// prepare defered glitch patching
terminal->glitch_cursor_x = event->cursor_position.x;
terminal->glitch_cursor_y = event->cursor_position.y;
} else {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
}
terminal->ad_state = AD_FP1_SEC_DEV_ATTRIB_QMCURSOR_POS_RECVED;
return true;
} else if (event->type == TERMPAINT_EV_RAW_DECREQTPARM) {
terminal->seen_dec_terminal_param = true;
// ignore
return true;
}
break;
case AD_FP1_QMCURSOR_POS_RECVED:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
if (terminal->glitch_cursor_y != -1) {
termpaintp_patch_misparsing_defered(terminal, integration, AD_FINISHED);
return true;
} else {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
}
} else if (event->type == TERMPAINT_EV_RAW_DECREQTPARM) {
terminal->seen_dec_terminal_param = true;
if (terminal->auto_detect_sec_device_attributes.len
&& termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT)
&& termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS)
&& termpaintp_str_ends_with(terminal->auto_detect_sec_device_attributes.data, (const uchar*)";0c")) {
terminal->terminal_type = TT_XTERM;
}
return true;
}
break;
case AD_FP1_SEC_DEV_ATTRIB_QMCURSOR_POS_RECVED:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
int_puts(integration, "\033[>0;1c");
int_puts(integration, "\033[5n");
int_awaiting_response(integration);
terminal->ad_state = AD_FP2_CURSOR_DONE;
return true;
} else if (event->type == TERMPAINT_EV_RAW_DECREQTPARM) {
terminal->seen_dec_terminal_param = true;
if (terminal->auto_detect_sec_device_attributes.len && event->raw.length == 4 && memcmp(event->raw.string, "\033[?x", 4) == 0
&& terminal->glitch_cursor_y == -1) {
// this triggers on VTE < 0.54 which has fragile dictionary based parsing.
// The self reporting stage would cause misparsing, so skip it here.
terminal->terminal_type = TT_VTE;
terminal->ad_state = AD_EXPECT_SYNC_TO_FINISH;
} else {
// ignore
}
return true;
}
break;
case AD_FP2_REQ:
if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
if (terminal->initial_cursor_y != event->cursor_position.y
|| terminal->initial_cursor_x != event->cursor_position.x) {
// prepare defered glitch patching
terminal->glitch_cursor_x = event->cursor_position.x;
terminal->glitch_cursor_y = event->cursor_position.y;
} else {
termpaint_terminal_promise_capability(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS);
}
terminal->ad_state = AD_FP2_CURSOR_DONE;
return true;
}
break;
case AD_FP2_CURSOR_DONE:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
if (terminal->terminal_type_confidence == 0) {
terminal->terminal_type = TT_BASE;
}
if (terminal->glitch_cursor_y == -1) {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
} else {
termpaintp_patch_misparsing_defered(terminal, integration, AD_FINISHED);
return true;
}
} else if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
terminal->ad_state = AD_FP2_SEC_DEV_ATTRIB_RECVED1;
return true;
}
break;
case AD_FP2_SEC_DEV_ATTRIB_RECVED1:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
if (terminal->terminal_type_confidence == 0) {
terminal->terminal_type = TT_BASE;
}
if (terminal->glitch_cursor_y == -1) {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
} else {
termpaintp_patch_misparsing_defered(terminal, integration, AD_FINISHED);
return true;
}
} else if (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB) {
if (terminal->auto_detect_sec_device_attributes.len) {
terminal->terminal_type = TT_KONSOLE;
} else if (terminal->terminal_type_confidence == 0) {
terminal->terminal_type = TT_BASE;
}
terminal->ad_state = AD_FP2_SEC_DEV_ATTRIB_RECVED2;
return true;
}
break;
case AD_FP2_SEC_DEV_ATTRIB_RECVED2:
if (event->type == TERMPAINT_EV_MISC && event->misc.atom == termpaint_input_i_resync()) {
if (terminal->glitch_cursor_y == -1) {
termpaintp_terminal_auto_detect_prepare_self_reporting(terminal, AD_SELF_REPORTING);
return true;
} else {
termpaintp_patch_misparsing_defered(terminal, integration, AD_FINISHED);
return true;
}
}
break;
// sub routine glitch patching
case AD_GLITCH_PATCHING:
if (event->type == TERMPAINT_EV_CURSOR_POSITION) {
if ((event->cursor_position.y < terminal->glitch_cursor_y)
|| ((event->cursor_position.y == terminal->glitch_cursor_y) && (event->cursor_position.x < terminal->glitch_cursor_x))) {
if (termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT)) {
int_puts(integration, " \033[?6n");
} else {
termpaint_input_expect_cursor_position_report(terminal->input);
int_puts(integration, " \033[6n");
}
return true;
} else {
terminal->glitch_cursor_y = -1; // disarm
terminal->ad_state = terminal->glitch_patching_next_state;
if (terminal->glitch_patching_next_state == AD_FINISHED) {
return false;
} else {
BUG("AD_GLITCH_PATCHING called with destination state != AD_FINISHED");
}
}
}
break;
case AD_HTERM_RECOVERY1:
if (event->type == TERMPAINT_EV_CHAR && event->c.length == 1
&& event->c.string[0] == '0' && event->c.modifier == TERMPAINT_MOD_ALT) {
terminal->ad_state = AD_HTERM_RECOVERY2;
return true;
} else if (event->type == TERMPAINT_EV_CHAR && event->c.length == 1
&& event->c.string[0] == 'n' && event->c.modifier == 0) {
// keep in recovery state.
return true;
} else if ((event->type == TERMPAINT_EV_CURSOR_POSITION)
|| (event->type == TERMPAINT_EV_RAW_SEC_DEV_ATTRIB)) {
// keep in recovery state.
return true;
}
break;
case AD_HTERM_RECOVERY2:
if (event->type == TERMPAINT_EV_CHAR && event->c.length == 1
&& event->c.string[0] == 'n' && event->c.modifier == 0) {
terminal->ad_state = AD_FINISHED;
return true;
}
break;
};
// if this code runs auto detection failed by running off into the weeds
int_debuglog_printf(terminal, "ran off autodetect: s=%d, e=%d\n", (int)terminal->ad_state, (int)event->type);
terminal->terminal_type = TT_TOODUMB;
terminal->ad_state = AD_FINISHED;
return false;
}
_Bool termpaint_terminal_auto_detect(termpaint_terminal *terminal) {
if (!terminal->event_cb) {
// bail out, running this without an event callback risks crashing
return false;
}
// reset state just to be safe
terminal->terminal_type = TT_UNKNOWN;
terminal->terminal_version = 0;
terminal->terminal_type_confidence = 0;
terminal->initial_cursor_x = -1;
terminal->initial_cursor_y = -1;
termpaintp_terminal_reset_capabilites(terminal);
termpaintp_terminal_auto_detect_event(terminal, nullptr);
int_flush(terminal->integration);
return true;
}
enum termpaint_auto_detect_state_enum termpaint_terminal_auto_detect_state(const termpaint_terminal *terminal) {
if (terminal->ad_state == AD_FINISHED) {
return termpaint_auto_detect_done;
} else if (terminal->ad_state == AD_NONE) {
return termpaint_auto_detect_none;
} else {
return termpaint_auto_detect_running;
}
}
bool termpaint_terminal_might_be_supported(const termpaint_terminal *terminal) {
return terminal->terminal_type != TT_INCOMPATIBLE;
}
void termpaint_terminal_auto_detect_result_text(const termpaint_terminal *terminal, char *buffer, int buffer_length) {
const char *term_type = nullptr;
switch (terminal->terminal_type) {
case TT_INCOMPATIBLE:
term_type = "incompatible with input handling";
break;
case TT_TOODUMB:
term_type = "toodumb";
break;
case TT_MISPARSING:
term_type = "misparsing";
break;
case TT_UNKNOWN:
term_type = "unknown";
break;
case TT_FULL:
term_type = "unknown full featured";
break;
case TT_BASE:
term_type = "base";
break;
case TT_LINUXVC:
term_type = "linux vc";
break;
case TT_KONSOLE:
term_type = "konsole";
break;
case TT_XTERM:
term_type = "xterm";
break;
case TT_VTE:
term_type = "vte";
break;
case TT_SCREEN:
term_type = "screen";
break;
case TT_TMUX:
term_type = "tmux";
break;
case TT_URXVT:
term_type = "urxvt";
break;
case TT_MLTERM:
term_type = "mlterm";
break;
case TT_TERMINOLOGY:
term_type = "terminology";
break;
case TT_MACOS:
term_type = "apple terminal";
break;
case TT_ITERM2:
term_type = "iterm2";
break;
case TT_MINTTY:
term_type = "mintty";
break;
case TT_KITTY:
term_type = "kitty";
break;
case TT_MSFT_TERMINAL:
term_type = "microsoft terminal";
break;
};
snprintf(buffer, buffer_length, "Type: %s(%d) %s seq:%s%s", term_type, terminal->terminal_version,
termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT) ? "safe-CPR" : "",
termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_CSI_GREATER) ? ">" : "",
termpaint_terminal_capable(terminal, TERMPAINT_CAPABILITY_CSI_EQUALS) ? "=" : "");
buffer[buffer_length-1] = 0;
}
const char *termpaint_terminal_self_reported_name_and_version(const termpaint_terminal *terminal) {
return terminal->terminal_self_reported_name_version.len ?
(const char*)terminal->terminal_self_reported_name_version.data
: nullptr;
}
static bool termpaintp_has_option(const char *options, const char *name) {
const char *p = options;
int name_len = strlen(name);
while (1) {
const char *found = strstr(p, name);
if (!found) {
break;
}
if (found == options || found[-1] == ' ') {
if (found[name_len] == 0 || found[name_len] == ' ') {
return true;
}
}
p = found + name_len;
}
return false;
}
static void termpaintp_terminal_setup_common(termpaint_terminal *terminal, const char *options) {
termpaint_str *init_sequence = &terminal->unpause_basic_setup;
termpaintp_prepend_str(&terminal->restore_seq_partial, (const uchar*)"\033[?7h");
terminal->did_terminal_disable_wrap = true;
termpaintp_str_assign(init_sequence, "\033[?7l");
termpaintp_prepend_str(&terminal->restore_seq_partial, (const uchar*)"\033[?66l");
termpaintp_str_append(init_sequence, "\033[?66h");
termpaintp_str_append(init_sequence, "\033[?1036h");
if (!termpaintp_has_option(options, "+kbdsig") && terminal->terminal_type == TT_XTERM) {
// xterm modify other characters
// in this keyboard event mode xterm does no longer send the traditional one byte ^C, ^Z ^\ sequences
// that the kernel tty layer uses to raise signals.
termpaintp_prepend_str(&terminal->restore_seq_partial, (const uchar*)"\033[>4m");
termpaintp_str_append(init_sequence, "\033[>4;2m");
}
}
void termpaint_terminal_setup_fullscreen(termpaint_terminal *terminal, int width, int height, const char *options) {
termpaint_integration *integration = terminal->integration;
termpaintp_terminal_setup_common(terminal, options);
termpaint_str *init_sequence = &terminal->unpause_basic_setup;
if (!termpaintp_has_option(options, "-altscreen")) {
int_puts(integration, "\033[?1049h");
terminal->altscreen_active = 1;
}
int_put_tps(integration, init_sequence);
int_flush(integration);
int_restore_sequence_complete(terminal);
int_restore_sequence_updated(terminal);
terminal->setup_state = SETUP_STATE_FULLSCREEN;
termpaint_surface_resize(&terminal->primary, width, height);
}
void termpaint_terminal_setup_inline(termpaint_terminal *terminal, int width, int height, const char *options) {
termpaint_integration *integration = terminal->integration;
termpaintp_terminal_setup_common(terminal, options);
termpaint_str *init_sequence = &terminal->unpause_basic_setup;
int_put_tps(integration, init_sequence);
int_flush(integration);
int_restore_sequence_complete(terminal);
int_restore_sequence_updated(terminal);
termpaint_surface_resize(&terminal->primary, width, height);
terminal->setup_state = SETUP_STATE_INLINE;
terminal->inline_current_terminal_cursor_line = 0;
}
void termpaint_terminal_set_inline(termpaint_terminal *terminal, _Bool enabled) {
if (enabled && terminal->setup_state == SETUP_STATE_INLINE) {
// already in inline mode
return;
}
if (!enabled && terminal->setup_state == SETUP_STATE_FULLSCREEN) {
// already fullscreen
return;
}
if (terminal->setup_state != SETUP_STATE_INLINE && terminal->setup_state != SETUP_STATE_FULLSCREEN) {
// bogus
return;
}
termpaint_integration *integration = terminal->integration;
if (!enabled) {
termpaintp_erase_inline(terminal);
terminal->inline_current_terminal_cursor_line = -1;
terminal->setup_state = SETUP_STATE_FULLSCREEN;
terminal->altscreen_active = 1;
int_restore_sequence_complete(terminal);
int_restore_sequence_updated(terminal);
int_puts(integration, "\033[?1049h");
} else {
// for terminals without alt screen support clear terminal.
int_puts(integration, "\033[H\033[2J");
terminal->altscreen_active = 0;
int_restore_sequence_complete(terminal);
int_restore_sequence_updated(terminal);
int_puts(integration, "\033[?1049l");
terminal->inline_current_terminal_cursor_line = 0;
terminal->last_inline_height = 0;
terminal->setup_state = SETUP_STATE_INLINE;
}
terminal->force_full_repaint = true;
}
const char* termpaint_terminal_restore_sequence(const termpaint_terminal *term) {
return (const char*)(term->restore_seq_cached.len ? term->restore_seq_cached.data : (const uchar*)"");
}
void termpaint_terminal_pause(termpaint_terminal *term) {
termpaint_terminal_pause_and_persistent(term, nullptr);
}
void termpaint_terminal_pause_and_persistent(termpaint_terminal *term, termpaint_surface *surface) {
termpaint_integration *integration = term->integration;
term->force_full_repaint = true;
bool saved_altscreen_active = term->altscreen_active;
if (term->setup_state == SETUP_STATE_INLINE) {
termpaintp_erase_inline(term);
if (surface) {
int saved_cursor_x = term->cursor_x;
int saved_cursor_y = term->cursor_y;
term->cursor_x = term->cursor_y = -1;
termpaintp_terminal_flush_with_surface(term, true, surface);
term->cursor_x = saved_cursor_x;
term->cursor_y = saved_cursor_y;
int_puts(integration, "\r\n");
// Output is persistent
term->inline_current_terminal_cursor_line = 0;
term->last_inline_height = 0;
}
} else {
if (surface) {
if (term->altscreen_active) {
// resetting term->altscreen_active here is important to keep the correct cursor position
int_puts(integration, "\033[?1049l");
term->altscreen_active = false;
int_restore_sequence_complete(term);
}
term->inline_current_terminal_cursor_line = 0;
term->last_inline_height = 0;
int saved_setup_state = term->setup_state;
int saved_cursor_x = term->cursor_x;
int saved_cursor_y = term->cursor_y;
term->setup_state = SETUP_STATE_INLINE;
term->cursor_x = term->cursor_y = -1;
termpaintp_terminal_flush_with_surface(term, true, surface);
term->setup_state = saved_setup_state;
term->cursor_x = saved_cursor_x;
term->cursor_y = saved_cursor_y;
int_puts(integration, "\r\n");
// Output is persistent
term->inline_current_terminal_cursor_line = 0;
term->last_inline_height = 0;
}
}
if (term->restore_seq_cached.len) {
int_write(integration, (const char*)term->restore_seq_cached.data, term->restore_seq_cached.len);
}
if (saved_altscreen_active != term->altscreen_active) {
term->altscreen_active = saved_altscreen_active;
int_restore_sequence_complete(term);
}
int_flush(integration);
}
void termpaint_terminal_unpause(termpaint_terminal *term) {
term->cursor_prev_data = -2;
termpaint_integration *integration = term->integration;
// reconstruct state after setup_fullscreen
int_put_tps(integration, &term->unpause_basic_setup);
if (term->altscreen_active) {
int_puts(integration, "\033[?1049h");
}
// save/push sequences
if (term->did_terminal_push_title) {
int_puts(integration, "\033[22t");
}
// other did_* sequences
if (term->did_terminal_enable_mouse) {
int_puts(integration, "\033[?1015h\033[?1006h");
}
// the rest
for (int i = 0; i < term->colors.allocated; i++) {
termpaint_color_entry* item_it = (termpaint_color_entry*)term->colors.buckets[i];
while (item_it) {
if (item_it->save_state == termpaint_save_state_ready) {
if (item_it->requested.len) {
int_puts(integration, "\033]");
int_uputs(integration, item_it->base.text);
int_puts(integration, ";");
int_uputs(integration, item_it->requested.data);
int_puts(integration, termpaintp_terminal_correct_string_terminator(term));
} else {
int_uputs(integration, item_it->restore.data);
}
}
item_it = (termpaint_color_entry*)item_it->base.next;
}
}
for (int i = 0; i < term->unpause_snippets.allocated; i++) {
termpaint_unpause_snippet* item_it = (termpaint_unpause_snippet*)term->unpause_snippets.buckets[i];
while (item_it) {
int_put_tps(integration, &item_it->sequences);
item_it = (termpaint_unpause_snippet*)item_it->base.next;
}
}
int_flush(integration);
}
static termpaint_str* termpaintp_terminal_get_unpause_slot(termpaint_terminal *term, const char *name) {
termpaint_unpause_snippet *snippet = termpaintp_hash_ensure(&term->unpause_snippets,
(const unsigned char*)name);
if (!snippet) {
return nullptr;
}
return &(snippet)->sequences;
}
termpaint_attr *termpaint_attr_new_or_nullptr(unsigned fg, unsigned bg) {
termpaint_attr *attr = calloc(1, sizeof(termpaint_attr));
if (!attr) {
return nullptr;
}
attr->fg_color = fg;
attr->bg_color = bg;
attr->deco_color = TERMPAINT_DEFAULT_COLOR;
return attr;
}
termpaint_attr *termpaint_attr_new(unsigned fg, unsigned bg) {
termpaint_attr *attr = termpaint_attr_new_or_nullptr(fg, bg);
if (!attr) {
termpaintp_oom_nolog();
}
return attr;
}
void termpaint_attr_free(termpaint_attr *attr) {
if (!attr) {
return;
}
free(attr->patch_setup);
free(attr->patch_cleanup);
free(attr);
}
termpaint_attr *termpaint_attr_clone_or_nullptr(const termpaint_attr *orig) {
termpaint_attr *attr = calloc(1, sizeof(termpaint_attr));
if (!attr) {
return nullptr;
}
attr->fg_color = orig->fg_color;
attr->bg_color = orig->bg_color;
attr->deco_color = orig->deco_color;
attr->flags = orig->flags;
if (orig->patch_setup) {
attr->patch_setup = ustrdup(orig->patch_setup);
if (!attr->patch_setup) {
termpaint_attr_free(attr);
return nullptr;
}
attr->patch_optimize = orig->patch_optimize;
}
if (orig->patch_cleanup) {
attr->patch_cleanup = ustrdup(orig->patch_cleanup);
if (!attr->patch_cleanup) {
termpaint_attr_free(attr);
return nullptr;
}
attr->patch_optimize = orig->patch_optimize;
}
return attr;
}
termpaint_attr *termpaint_attr_clone(const termpaint_attr *orig) {
termpaint_attr *attr = termpaint_attr_clone_or_nullptr(orig);
if (!attr) {
termpaintp_oom_nolog();
}
return attr;
}
void termpaint_attr_set_fg(termpaint_attr *attr, unsigned fg) {
attr->fg_color = fg;
}
void termpaint_attr_set_bg(termpaint_attr *attr, unsigned bg) {
attr->bg_color = bg;
}
void termpaint_attr_set_deco(termpaint_attr *attr, unsigned deco_color) {
attr->deco_color = deco_color;
}
void termpaint_attr_set_style(termpaint_attr *attr, int bits) {
attr->flags |= bits & TERMPAINT_STYLE_PASSTHROUGH;
if (bits & ~TERMPAINT_STYLE_PASSTHROUGH) {
if (bits & TERMPAINT_STYLE_UNDERLINE) {
attr->flags = (attr->flags & ~CELL_ATTR_UNDERLINE_MASK) | CELL_ATTR_UNDERLINE_SINGLE;
} else if (bits & TERMPAINT_STYLE_UNDERLINE_DBL) {
attr->flags = (attr->flags & ~CELL_ATTR_UNDERLINE_MASK) | CELL_ATTR_UNDERLINE_DOUBLE;
} else if (bits & TERMPAINT_STYLE_UNDERLINE_CURLY) {
attr->flags = (attr->flags & ~CELL_ATTR_UNDERLINE_MASK) | CELL_ATTR_UNDERLINE_CURLY;
}
}
}
void termpaint_attr_unset_style(termpaint_attr *attr, int bits) {
attr->flags &= ~bits | ~TERMPAINT_STYLE_PASSTHROUGH;
if (bits & ~TERMPAINT_STYLE_PASSTHROUGH) {
if (bits & TERMPAINT_STYLE_UNDERLINE) {
attr->flags = attr->flags & ~CELL_ATTR_UNDERLINE_MASK;
} else if (bits & TERMPAINT_STYLE_UNDERLINE_DBL) {
attr->flags = attr->flags & ~CELL_ATTR_UNDERLINE_MASK;
} else if (bits & TERMPAINT_STYLE_UNDERLINE_CURLY) {
attr->flags = attr->flags & ~CELL_ATTR_UNDERLINE_MASK;
}
}
}
void termpaint_attr_reset_style(termpaint_attr *attr) {
attr->flags = 0;
}
bool termpaint_attr_set_patch_mustcheck(termpaint_attr *attr, bool optimize, const char *setup, const char *cleanup) {
free(attr->patch_setup);
attr->patch_setup = nullptr;
free(attr->patch_cleanup);
attr->patch_cleanup = nullptr;
if (!setup || !cleanup) {
attr->patch_optimize = false;
} else {
attr->patch_optimize = optimize;
attr->patch_setup = (uchar*)strdup(setup);
if (!attr->patch_setup) {
termpaint_attr_set_patch(attr, false, nullptr, nullptr);
return false;
}
attr->patch_cleanup = (uchar*)strdup(cleanup);
if (!attr->patch_cleanup) {
termpaint_attr_set_patch(attr, false, nullptr, nullptr);
return false;
}
}
return true;
}
void termpaint_attr_set_patch(termpaint_attr *attr, bool optimize, const char *setup, const char *cleanup) {
if (!termpaint_attr_set_patch_mustcheck(attr, optimize, setup, cleanup)) {
termpaintp_oom_nolog();
}
}
termpaint_text_measurement *termpaint_text_measurement_new_or_nullptr(const termpaint_surface *surface) {
// Make sure to fail early when a nullptr is passed, as this function only copies the pointer.
if (!surface) {
BUG("termpaint_text_measurement_new called without valid surface");
}
termpaint_text_measurement *m = malloc(sizeof(termpaint_text_measurement));
if (!m) {
return nullptr;
}
m->terminal = surface->terminal;
termpaint_text_measurement_reset(m);
return m;
}
termpaint_text_measurement *termpaint_text_measurement_new(const termpaint_surface *surface) {
termpaint_text_measurement *m = termpaint_text_measurement_new_or_nullptr(surface);
if (!m) {
termpaintp_oom(surface->terminal);
}
return m;
}
void termpaint_text_measurement_free(termpaint_text_measurement *m) {
if (!m) {
return;
}
free(m);
}
void termpaint_text_measurement_reset(termpaint_text_measurement *m) {
m->pending_codepoints = 0;
m->pending_ref = 0;
m->pending_clusters = 0;
m->pending_width = 0;
m->last_codepoints = -1;
m->last_ref = -1;
m->last_clusters = -1;
m->last_width = -1;
m->state = TM_INITIAL;
m->limit_codepoints = -1;
m->limit_ref = -1;
m->limit_clusters = -1;
m->limit_width = -1;
m->decoder_state = TMD_INITIAL;
}
int termpaint_text_measurement_pending_ref(const termpaint_text_measurement *m) {
int result = m->pending_ref;
if (m->decoder_state == TMD_PARTIAL_UTF16) {
result += 1;
} else if (m->decoder_state == TMD_PARTIAL_UTF8) {
result += m->utf8_available;
}
return result;
}
int termpaint_text_measurement_last_codepoints(const termpaint_text_measurement *m) {
return m->last_codepoints;
}
int termpaint_text_measurement_last_clusters(const termpaint_text_measurement *m) {
return m->last_clusters;
}
int termpaint_text_measurement_last_width(const termpaint_text_measurement *m) {
return m->last_width;
}
int termpaint_text_measurement_last_ref(const termpaint_text_measurement *m) {
return m->last_ref;
}
int termpaint_text_measurement_limit_codepoints(const termpaint_text_measurement *m) {
return m->limit_codepoints;
}
void termpaint_text_measurement_set_limit_codepoints(termpaint_text_measurement *m, int new_value) {
m->limit_codepoints = new_value;
}
int termpaint_text_measurement_limit_clusters(const termpaint_text_measurement *m) {
return m->limit_clusters;
}
void termpaint_text_measurement_set_limit_clusters(termpaint_text_measurement *m, int new_value) {
m->limit_clusters = new_value;
}
int termpaint_text_measurement_limit_width(const termpaint_text_measurement *m) {
return m->limit_width;
}
void termpaint_text_measurement_set_limit_width(termpaint_text_measurement *m, int new_value) {
m->limit_width = new_value;
}
int termpaint_text_measurement_limit_ref(const termpaint_text_measurement *m) {
return m->limit_ref;
}
void termpaint_text_measurement_set_limit_ref(termpaint_text_measurement *m, int new_value) {
m->limit_ref = new_value;
}
static inline void termpaintp_text_measurement_commit(termpaint_text_measurement *m) {
m->last_codepoints = m->pending_codepoints;
m->last_clusters = m->pending_clusters;
m->last_width = m->pending_width;
m->last_ref = m->pending_ref;
}
// -1 if no limit reached, 1 if some limit exceeded, 0 if no limit exceeded and some limit reached
static int termpaintp_text_measurement_cmp_limits(termpaint_text_measurement *m) {
int ret = -1;
if (m->limit_codepoints >= 0) {
if (m->pending_codepoints == m->limit_codepoints) {
ret = 0;
} else if (m->pending_codepoints > m->limit_codepoints) {
return 1;
}
}
if (m->limit_clusters >= 0) {
if (m->pending_clusters == m->limit_clusters) {
ret = 0;
} else if (m->pending_clusters > m->limit_clusters) {
return 1;
}
}
if (m->limit_width >= 0) {
if (m->pending_width == m->limit_width) {
ret = 0;
} else if (m->pending_width > m->limit_width) {
return 1;
}
}
if (m->limit_ref >= 0) {
if (m->pending_ref == m->limit_ref) {
ret = 0;
} else if (m->pending_ref > m->limit_ref) {
return 1;
}
}
return ret;
}
static void termpaintp_text_measurement_undo(termpaint_text_measurement *m) {
m->pending_codepoints = m->last_codepoints;
m->pending_ref = m->last_ref;
m->pending_clusters = m->last_clusters;
m->pending_width = m->last_width;
m->state = TM_IN_CLUSTER;
m->decoder_state = TMD_INITIAL;
}
int termpaint_text_measurement_feed_codepoint(termpaint_text_measurement *m, int ch, int ref_adjust) {
const termpaintp_width *char_width_table = m->terminal->char_width_table;
// ATTENTION keep this in sync with actual write to surface
int ch_sanitized = replace_unusable_codepoints(ch);
int width = termpaintp_char_width(char_width_table, ch_sanitized);
if (width == 0) {
if (m->state == TM_INITIAL) {
// Assume this will be input in this way into write which will supply it with U+00a0 as base.
// We can ignore this non spaceing mark and just calculate for U+00a0 because what is needed is
// * adding ref_adjust to ref (to account for the non spaceing mark)
// * adding one codepoint to ref (also to account for the non spaceing mark)
// * and incrementing the cluster and width just as U+00a0 would do. While we can ignore the non spacing
// mark for cluster/width purposes.
// This is exactly what happens on feeding U+00a0, so just do that instead of creating another implementation.
return termpaint_text_measurement_feed_codepoint(m, 0xa0, ref_adjust);
}
++m->pending_codepoints;
m->pending_ref += ref_adjust;
// accumulates into cluster. Nothing do do here.
return 0;
} else {
int limit_rel = termpaintp_text_measurement_cmp_limits(m);
if (limit_rel == 0) { // no limit exceeded, some limit hit exactly -> commit cluster and use that as best match
termpaintp_text_measurement_commit(m);
m->state = TM_IN_CLUSTER;
return TERMPAINT_MEASURE_NEW_CLUSTER | TERMPAINT_MEASURE_LIMIT_REACHED;
} else if (limit_rel < 0) { // no limit reached -> commit cluster and go on
// advance last full cluster
termpaintp_text_measurement_commit(m);
m->state = TM_IN_CLUSTER;
++m->pending_codepoints;
m->pending_ref += ref_adjust;
m->pending_width += width;
m->pending_clusters += 1;
if (ch == '\x7f') {
// clear marker does not allow any modifiers
m->state = TM_INITIAL;
}
return TERMPAINT_MEASURE_NEW_CLUSTER;
} else { // some limit exceeded -> return with previous cluster as best match
termpaintp_text_measurement_undo(m);
return TERMPAINT_MEASURE_LIMIT_REACHED;
}
}
}
_Bool termpaint_text_measurement_feed_utf32(termpaint_text_measurement *m, const uint32_t *chars, int length, _Bool final) {
for (int i = 0; i < length; i++) {
if (termpaint_text_measurement_feed_codepoint(m, (int)chars[i], 1) & TERMPAINT_MEASURE_LIMIT_REACHED) {
return true;
}
}
if (final) {
int limit_rel = termpaintp_text_measurement_cmp_limits(m);
if (limit_rel == 0) { // no limit exceeded, some limit hit exactly -> commit cluster and use that as best match
termpaintp_text_measurement_commit(m);
return true;
} else if (limit_rel < 0) { // no limit reached -> commit cluster
termpaintp_text_measurement_commit(m);
return false;
} else { // some limit exceeded -> return with previous cluster as best match
termpaintp_text_measurement_undo(m);
return true;
}
}
return false;
}
_Bool termpaint_text_measurement_feed_utf16(termpaint_text_measurement *m, const uint16_t *code_units, int length, _Bool final) {
if (m->decoder_state != TMD_INITIAL && m->decoder_state != TMD_PARTIAL_UTF16) {
// This is bogus usage, but just paper over it
m->decoder_state = TMD_INITIAL;
}
for (int i = 0; i < length; i++) {
int ch = code_units[i];
int adjust = 1;
if (termpaintp_utf16_is_high_surrogate(code_units[i])) {
if (m->decoder_state != TMD_INITIAL) {
// This is bogus usage, but just paper over it
ch = 0xFFFD;
} else {
m->decoder_state = TMD_PARTIAL_UTF16;
m->utf_16_high = code_units[i];
continue;
}
}
if (termpaintp_utf16_is_low_surrogate(code_units[i])) {
if (m->decoder_state != TMD_PARTIAL_UTF16) {
// This is bogus usage, but just paper over it
ch = 0xFFFD;
} else {
adjust = 2;
ch = termpaintp_utf16_combine(m->utf_16_high, code_units[i]);
}
}
m->decoder_state = TMD_INITIAL;
if (termpaint_text_measurement_feed_codepoint(m, ch, adjust) & TERMPAINT_MEASURE_LIMIT_REACHED) {
return true;
}
}
if (final) {
int limit_rel = termpaintp_text_measurement_cmp_limits(m);
if (limit_rel == 0) { // no limit exceeded, some limit hit exactly -> commit cluster and use that as best match
termpaintp_text_measurement_commit(m);
return true;
} else if (limit_rel < 0) { // no limit reached -> commit cluster
termpaintp_text_measurement_commit(m);
return false;
} else { // some limit exceeded -> return with previous cluster as best match
termpaintp_text_measurement_undo(m);
return true;
}
}
return false;
}
_Bool termpaint_text_measurement_feed_utf8(termpaint_text_measurement *m, const char *code_units, int length, _Bool final) {
if (m->decoder_state != TMD_INITIAL && m->decoder_state != TMD_PARTIAL_UTF8) {
// This is bogus usage, but just paper over it
m->decoder_state = TMD_INITIAL;
}
for (int i = 0; i < length; i++) {
int ch;
int adjust = 1;
if (m->decoder_state == TMD_INITIAL) {
int len = termpaintp_utf8_len(code_units[i]);
if (len == 1) {
ch = code_units[i];
} else {
m->decoder_state = TMD_PARTIAL_UTF8;
m->utf8_size = len;
m->utf8_units[0] = code_units[i];
m->utf8_available = 1;
continue;
}
} else {
m->utf8_units[m->utf8_available] = code_units[i];
m->utf8_available++;
adjust = m->utf8_available;
if (m->utf8_available == m->utf8_size) {
if (termpaintp_check_valid_sequence(m->utf8_units, m->utf8_size)) {
ch = termpaintp_utf8_decode_from_utf8(m->utf8_units, m->utf8_size);
} else {
// This is bogus usage, but just paper over it
ch = 0xFFFD;
}
} else if (m->utf8_available > m->utf8_size) {
// This is bogus usage, but just paper over it
ch = 0xFFFD;
} else {
continue;
}
m->decoder_state = TMD_INITIAL;
}
if (termpaint_text_measurement_feed_codepoint(m, ch, adjust) & TERMPAINT_MEASURE_LIMIT_REACHED) {
return true;
}
}
if (final) {
int limit_rel = termpaintp_text_measurement_cmp_limits(m);
if (limit_rel == 0) { // no limit exceeded, some limit hit exactly -> commit cluster and use that as best match
termpaintp_text_measurement_commit(m);
return true;
} else if (limit_rel < 0) { // no limit reached -> commit cluster
termpaintp_text_measurement_commit(m);
return false;
} else { // some limit exceeded -> return with previous cluster as best match
termpaintp_text_measurement_undo(m);
return true;
}
}
return false;
}
bool termpaint_terminal_set_title_mustcheck(termpaint_terminal *term, const char *title, int mode) {
if (mode != TERMPAINT_TITLE_MODE_PREFER_RESTORE) {
if (!termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_TITLE_RESTORE)) {
return true;
}
}
termpaint_integration *integration = term->integration;
if (!term->did_terminal_push_title) {
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)"\033[23t");
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
int_puts(integration, "\033[22t");
term->did_terminal_push_title = true;
}
termpaint_str* sequences = termpaintp_terminal_get_unpause_slot(term, "title");
if (!sequences) {
return false;
}
TERMPAINT_STR_ASSIGN3_MUSTCHECK(sequences, S, "\033]2;",
F, title,
S, termpaintp_terminal_correct_string_terminator(term));
if (!sequences->len) {
return false;
}
int_put_tps(integration, sequences);
int_flush(integration);
return true;
}
void termpaint_terminal_set_title(termpaint_terminal *term, const char *title, int mode) {
if (!termpaint_terminal_set_title_mustcheck(term, title, mode)) {
termpaintp_oom(term);
}
}
bool termpaint_terminal_set_icon_title_mustcheck(termpaint_terminal *term, const char *title, int mode) {
if (mode != TERMPAINT_TITLE_MODE_PREFER_RESTORE) {
if (!termpaint_terminal_capable(term, TERMPAINT_CAPABILITY_TITLE_RESTORE)) {
return true;
}
}
termpaint_integration *integration = term->integration;
if (!term->did_terminal_push_title) {
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)"\033[23t");
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
int_puts(integration, "\033[22t");
term->did_terminal_push_title = true;
}
termpaint_str* sequences = termpaintp_terminal_get_unpause_slot(term, "icon title");
if (!sequences) {
return false;
}
TERMPAINT_STR_ASSIGN3_MUSTCHECK(sequences, S, "\033]1;",
F, title,
S, termpaintp_terminal_correct_string_terminator(term));
if (!sequences->len) {
return false;
}
int_put_tps(integration, sequences);
int_flush(integration);
return true;
}
void termpaint_terminal_set_icon_title(termpaint_terminal *term, const char *title, int mode) {
if (!termpaint_terminal_set_icon_title_mustcheck(term, title, mode)) {
termpaintp_oom(term);
}
}
void termpaint_terminal_bell(termpaint_terminal *term) {
termpaint_integration *integration = term->integration;
int_puts(integration, "\a");
int_flush(integration);
}
#define DISABLE_MOUSE_SEQUENCE "\033[?1003l\033[?1002l\033[?1000l\033[?1006l\033[?1015l"
_Bool termpaint_terminal_set_mouse_mode_mustcheck(termpaint_terminal *term, int mouse_mode) {
termpaint_integration *integration = term->integration;
if (mouse_mode != TERMPAINT_MOUSE_MODE_OFF) {
if (!term->did_terminal_add_mouse_to_restore) {
termpaint_terminal_expect_legacy_mouse_reports(term, TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE);
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)DISABLE_MOUSE_SEQUENCE);
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
term->did_terminal_add_mouse_to_restore = true;
}
} else {
if (term->did_terminal_enable_mouse) {
term->did_terminal_enable_mouse = false;
int_puts(integration, DISABLE_MOUSE_SEQUENCE);
int_flush(integration);
termpaint_str* sequences = termpaintp_terminal_get_unpause_slot(term, "mouse");
if (sequences) {
if (!termpaintp_str_assign_mustcheck(sequences, "")) {
return false;
}
}
}
return true;
}
termpaint_str* sequences = termpaintp_terminal_get_unpause_slot(term, "mouse");
if (!sequences) {
return false;
}
if (mouse_mode == TERMPAINT_MOUSE_MODE_CLICKS) {
if (!termpaintp_str_assign_mustcheck(sequences, "\033[?1002l\033[?1003l\033[?1000h")) {
return false;
}
} else if (mouse_mode == TERMPAINT_MOUSE_MODE_DRAG) {
if (!termpaintp_str_assign_mustcheck(sequences, "\033[?1003l\033[?1000h\033[?1002h")) {
return false;
}
} else if (mouse_mode == TERMPAINT_MOUSE_MODE_MOVEMENT) {
if (!termpaintp_str_assign_mustcheck(sequences, "\033[?1000h\033[?1002h\033[?1003h")) {
return false;
}
}
if (!term->did_terminal_enable_mouse) {
term->did_terminal_enable_mouse = true;
int_puts(integration, "\033[?1015h\033[?1006h");
}
int_put_tps(integration, sequences);
int_flush(integration);
return true;
}
void termpaint_terminal_set_mouse_mode(termpaint_terminal *term, int mouse_mode) {
if (!termpaint_terminal_set_mouse_mode_mustcheck(term, mouse_mode)) {
termpaintp_oom(term);
}
}
bool termpaint_terminal_request_focus_change_reports_mustcheck(termpaint_terminal *term, bool enabled) {
if (enabled && !term->did_terminal_add_focusreporting_to_restore) {
term->did_terminal_add_focusreporting_to_restore = true;
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)"\033[?1004l");
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
}
termpaint_integration *integration = term->integration;
termpaint_str* sequences = termpaintp_terminal_get_unpause_slot(term, "focus report");
if (!sequences) {
return false;
}
if (enabled) {
if (!termpaintp_str_assign_mustcheck(sequences, "\033[?1004h")) {
return false;
}
} else {
if (!termpaintp_str_assign_mustcheck(sequences, "\033[?1004l")) {
return false;
}
}
int_put_tps(integration, sequences);
int_flush(integration);
return true;
}
void termpaint_terminal_request_focus_change_reports(termpaint_terminal *term, bool enabled) {
if (!termpaint_terminal_request_focus_change_reports_mustcheck(term, enabled)) {
termpaintp_oom(term);
}
}
bool termpaint_terminal_request_tagged_paste_mustcheck(termpaint_terminal *term, bool enabled) {
if (enabled && !term->did_terminal_add_bracketedpaste_to_restore) {
term->did_terminal_add_bracketedpaste_to_restore = true;
termpaintp_prepend_str(&term->restore_seq_partial, (const uchar*)"\033[?2004l");
int_restore_sequence_complete(term);
int_restore_sequence_updated(term);
}
termpaint_integration *integration = term->integration;
termpaint_str* sequences = termpaintp_terminal_get_unpause_slot(term, "bracketed paste");
if (!sequences) {
return false;
}
if (enabled) {
if (!termpaintp_str_assign_mustcheck(sequences, "\033[?2004h")) {
return false;
}
} else {
if (!termpaintp_str_assign_mustcheck(sequences, "\033[?2004l")) {
return false;
}
}
int_put_tps(integration, sequences);
int_flush(integration);
return true;
}
void termpaint_terminal_request_tagged_paste(termpaint_terminal *term, bool enabled) {
if (!termpaint_terminal_request_tagged_paste_mustcheck(term, enabled)) {
termpaintp_oom(term);
}
}
// --- tests
static bool termpaintp_test_quantize_to_256(void) {
termpaint_terminal terminal;
terminal.cache_should_use_truecolor = false;
terminal.capabilities[TERMPAINT_CAPABILITY_88_COLOR] = false;
struct pal_entry { int nr; int r,g,b; };
const struct pal_entry palette[240] = {
{ 16, 0, 0, 0 }, { 17, 0, 0, 95 }, { 18, 0, 0, 135 }, { 19, 0, 0, 175 }, { 20, 0, 0, 215 },
{ 21, 0, 0, 255 }, { 22, 0, 95, 0 }, { 23, 0, 95, 95 }, { 24, 0, 95, 135 }, { 25, 0, 95, 175 },
{ 26, 0, 95, 215 }, { 27, 0, 95, 255 }, { 28, 0, 135, 0 }, { 29, 0, 135, 95 }, { 30, 0, 135, 135 },
{ 31, 0, 135, 175 }, { 32, 0, 135, 215 }, { 33, 0, 135, 255 }, { 34, 0, 175, 0 }, { 35, 0, 175, 95 },
{ 36, 0, 175, 135 }, { 37, 0, 175, 175 }, { 38, 0, 175, 215 }, { 39, 0, 175, 255 }, { 40, 0, 215, 0 },
{ 41, 0, 215, 95 }, { 42, 0, 215, 135 }, { 43, 0, 215, 175 }, { 44, 0, 215, 215 }, { 45, 0, 215, 255 },
{ 46, 0, 255, 0 }, { 47, 0, 255, 95 }, { 48, 0, 255, 135 }, { 49, 0, 255, 175 }, { 50, 0, 255, 215 },
{ 51, 0, 255, 255 }, { 52, 95, 0, 0 }, { 53, 95, 0, 95 }, { 54, 95, 0, 135 }, { 55, 95, 0, 175 },
{ 56, 95, 0, 215 }, { 57, 95, 0, 255 }, { 58, 95, 95, 0 }, { 59, 95, 95, 95 }, { 60, 95, 95, 135 },
{ 61, 95, 95, 175 }, { 62, 95, 95, 215 }, { 63, 95, 95, 255 }, { 64, 95, 135, 0 }, { 65, 95, 135, 95 },
{ 66, 95, 135, 135 }, { 67, 95, 135, 175 }, { 68, 95, 135, 215 }, { 69, 95, 135, 255 }, { 70, 95, 175, 0 },
{ 71, 95, 175, 95 }, { 72, 95, 175, 135 }, { 73, 95, 175, 175 }, { 74, 95, 175, 215 }, { 75, 95, 175, 255 },
{ 76, 95, 215, 0 }, { 77, 95, 215, 95 }, { 78, 95, 215, 135 }, { 79, 95, 215, 175 }, { 80, 95, 215, 215 },
{ 81, 95, 215, 255 }, { 82, 95, 255, 0 }, { 83, 95, 255, 95 }, { 84, 95, 255, 135 }, { 85, 95, 255, 175 },
{ 86, 95, 255, 215 }, { 87, 95, 255, 255 }, { 88, 135, 0, 0 }, { 89, 135, 0, 95 }, { 90, 135, 0, 135 },
{ 91, 135, 0, 175 }, { 92, 135, 0, 215 }, { 93, 135, 0, 255 }, { 94, 135, 95, 0 }, { 95, 135, 95, 95 },
{ 96, 135, 95, 135 }, { 97, 135, 95, 175 }, { 98, 135, 95, 215 }, { 99, 135, 95, 255 }, { 100, 135, 135, 0 },
{ 101, 135, 135, 95 }, { 102, 135, 135, 135 }, { 103, 135, 135, 175 }, { 104, 135, 135, 215 }, { 105, 135, 135, 255 },
{ 106, 135, 175, 0 }, { 107, 135, 175, 95 }, { 108, 135, 175, 135 }, { 109, 135, 175, 175 }, { 110, 135, 175, 215 },
{ 111, 135, 175, 255 }, { 112, 135, 215, 0 }, { 113, 135, 215, 95 }, { 114, 135, 215, 135 }, { 115, 135, 215, 175 },
{ 116, 135, 215, 215 }, { 117, 135, 215, 255 }, { 118, 135, 255, 0 }, { 119, 135, 255, 95 }, { 120, 135, 255, 135 },
{ 121, 135, 255, 175 }, { 122, 135, 255, 215 }, { 123, 135, 255, 255 }, { 124, 175, 0, 0 }, { 125, 175, 0, 95 },
{ 126, 175, 0, 135 }, { 127, 175, 0, 175 }, { 128, 175, 0, 215 }, { 129, 175, 0, 255 }, { 130, 175, 95, 0 },
{ 131, 175, 95, 95 }, { 132, 175, 95, 135 }, { 133, 175, 95, 175 }, { 134, 175, 95, 215 }, { 135, 175, 95, 255 },
{ 136, 175, 135, 0 }, { 137, 175, 135, 95 }, { 138, 175, 135, 135 }, { 139, 175, 135, 175 }, { 140, 175, 135, 215 },
{ 141, 175, 135, 255 }, { 142, 175, 175, 0 }, { 143, 175, 175, 95 }, { 144, 175, 175, 135 }, { 145, 175, 175, 175 },
{ 146, 175, 175, 215 }, { 147, 175, 175, 255 }, { 148, 175, 215, 0 }, { 149, 175, 215, 95 }, { 150, 175, 215, 135 },
{ 151, 175, 215, 175 }, { 152, 175, 215, 215 }, { 153, 175, 215, 255 }, { 154, 175, 255, 0 }, { 155, 175, 255, 95 },
{ 156, 175, 255, 135 }, { 157, 175, 255, 175 }, { 158, 175, 255, 215 }, { 159, 175, 255, 255 }, { 160, 215, 0, 0 },
{ 161, 215, 0, 95 }, { 162, 215, 0, 135 }, { 163, 215, 0, 175 }, { 164, 215, 0, 215 }, { 165, 215, 0, 255 },
{ 166, 215, 95, 0 }, { 167, 215, 95, 95 }, { 168, 215, 95, 135 }, { 169, 215, 95, 175 }, { 170, 215, 95, 215 },
{ 171, 215, 95, 255 }, { 172, 215, 135, 0 }, { 173, 215, 135, 95 }, { 174, 215, 135, 135 }, { 175, 215, 135, 175 },
{ 176, 215, 135, 215 }, { 177, 215, 135, 255 }, { 178, 215, 175, 0 }, { 179, 215, 175, 95 }, { 180, 215, 175, 135 },
{ 181, 215, 175, 175 }, { 182, 215, 175, 215 }, { 183, 215, 175, 255 }, { 184, 215, 215, 0 }, { 185, 215, 215, 95 },
{ 186, 215, 215, 135 }, { 187, 215, 215, 175 }, { 188, 215, 215, 215 }, { 189, 215, 215, 255 }, { 190, 215, 255, 0 },
{ 191, 215, 255, 95 }, { 192, 215, 255, 135 }, { 193, 215, 255, 175 }, { 194, 215, 255, 215 }, { 195, 215, 255, 255 },
{ 196, 255, 0, 0 }, { 197, 255, 0, 95 }, { 198, 255, 0, 135 }, { 199, 255, 0, 175 }, { 200, 255, 0, 215 }, { 201, 255, 0, 255 },
{ 202, 255, 95, 0 }, { 203, 255, 95, 95 }, { 204, 255, 95, 135 }, { 205, 255, 95, 175 }, { 206, 255, 95, 215 },
{ 207, 255, 95, 255 }, { 208, 255, 135, 0 }, { 209, 255, 135, 95 }, { 210, 255, 135, 135 }, { 211, 255, 135, 175 },
{ 212, 255, 135, 215 }, { 213, 255, 135, 255 }, { 214, 255, 175, 0 }, { 215, 255, 175, 95 }, { 216, 255, 175, 135 },
{ 217, 255, 175, 175 }, { 218, 255, 175, 215 }, { 219, 255, 175, 255 }, { 220, 255, 215, 0 }, { 221, 255, 215, 95 },
{ 222, 255, 215, 135 }, { 223, 255, 215, 175 }, { 224, 255, 215, 215 }, { 225, 255, 215, 255 }, { 226, 255, 255, 0 },
{ 227, 255, 255, 95 }, { 228, 255, 255, 135 }, { 229, 255, 255, 175 }, { 230, 255, 255, 215 }, { 231, 255, 255, 255 },
{ 232, 8, 8, 8 }, { 233, 18, 18, 18 }, { 234, 28, 28, 28 }, { 235, 38, 38, 38 }, { 236, 48, 48, 48 },
{ 237, 58, 58, 58 }, { 238, 68, 68, 68 }, { 239, 78, 78, 78 }, { 240, 88, 88, 88 }, { 241, 98, 98, 98 },
{ 242, 108, 108, 108 }, { 243, 118, 118, 118 }, { 244, 128, 128, 128 }, { 245, 138, 138, 138 },
{ 246, 148, 148, 148 }, { 247, 158, 158, 158 }, { 248, 168, 168, 168 }, { 249, 178, 178, 178 },
{ 250, 188, 188, 188 }, { 251, 198, 198, 198 }, { 252, 208, 208, 208 }, { 253, 218, 218, 218 },
{ 254, 228, 228, 228 }, { 255, 238, 238, 238 },
};
for (int r = 0; r < 256; r++) for (int g = 0; g < 256; g++) for (int b = 0; b < 256; b++) {
int best_metric = 0x7fffffff;
unsigned candidates[10] = { 0 };
int candidates_count = 0;
for (int i = 0; i < 240; i++) {
#define SQ(x) ((x) * (x))
const int cur_metric = SQ(palette[i].r - r) + SQ(palette[i].g - g) + SQ(palette[i].b - b);
#undef SQ
if (cur_metric < best_metric) {
candidates_count = 0;
candidates[candidates_count++] = TERMPAINT_INDEXED_COLOR + palette[i].nr;
best_metric = cur_metric;
} else if (cur_metric == best_metric) {
candidates[candidates_count++] = TERMPAINT_INDEXED_COLOR + palette[i].nr;
}
}
if (candidates_count == 9) {
return false;
}
unsigned res = termpaintp_quantize_color(&terminal, TERMPAINT_RGB_COLOR(r, g, b));
bool ok = false;
for (int i = 0; i < candidates_count; i++) {
if (candidates[i] == res) {
ok = true;
break;
}
}
if (!ok) {
return false;
}
}
return true;
}
static bool termpaintp_test_quantize_to_88(void) {
termpaint_terminal terminal;
terminal.cache_should_use_truecolor = false;
terminal.capabilities[TERMPAINT_CAPABILITY_88_COLOR] = true;
struct pal_entry { int nr; int r,g,b; };
const struct pal_entry palette[72] = {
{ 16, 0x00, 0x00, 0x00 }, { 17, 0x00, 0x00, 0x8b }, { 18, 0x00, 0x00, 0xcd }, { 19, 0x00, 0x00, 0xff },
{ 20, 0x00, 0x8b, 0x00 }, { 21, 0x00, 0x8b, 0x8b }, { 22, 0x00, 0x8b, 0xcd }, { 23, 0x00, 0x8b, 0xff },
{ 24, 0x00, 0xcd, 0x00 }, { 25, 0x00, 0xcd, 0x8b }, { 26, 0x00, 0xcd, 0xcd }, { 27, 0x00, 0xcd, 0xff },
{ 28, 0x00, 0xff, 0x00 }, { 29, 0x00, 0xff, 0x8b }, { 30, 0x00, 0xff, 0xcd }, { 31, 0x00, 0xff, 0xff },
{ 32, 0x8b, 0x00, 0x00 }, { 33, 0x8b, 0x00, 0x8b }, { 34, 0x8b, 0x00, 0xcd }, { 35, 0x8b, 0x00, 0xff },
{ 36, 0x8b, 0x8b, 0x00 }, { 37, 0x8b, 0x8b, 0x8b }, { 38, 0x8b, 0x8b, 0xcd }, { 39, 0x8b, 0x8b, 0xff },
{ 40, 0x8b, 0xcd, 0x00 }, { 41, 0x8b, 0xcd, 0x8b }, { 42, 0x8b, 0xcd, 0xcd }, { 43, 0x8b, 0xcd, 0xff },
{ 44, 0x8b, 0xff, 0x00 }, { 45, 0x8b, 0xff, 0x8b }, { 46, 0x8b, 0xff, 0xcd }, { 47, 0x8b, 0xff, 0xff },
{ 48, 0xcd, 0x00, 0x00 }, { 49, 0xcd, 0x00, 0x8b }, { 50, 0xcd, 0x00, 0xcd }, { 51, 0xcd, 0x00, 0xff },
{ 52, 0xcd, 0x8b, 0x00 }, { 53, 0xcd, 0x8b, 0x8b }, { 54, 0xcd, 0x8b, 0xcd }, { 55, 0xcd, 0x8b, 0xff },
{ 56, 0xcd, 0xcd, 0x00 }, { 57, 0xcd, 0xcd, 0x8b }, { 58, 0xcd, 0xcd, 0xcd }, { 59, 0xcd, 0xcd, 0xff },
{ 60, 0xcd, 0xff, 0x00 }, { 61, 0xcd, 0xff, 0x8b }, { 62, 0xcd, 0xff, 0xcd }, { 63, 0xcd, 0xff, 0xff },
{ 64, 0xff, 0x00, 0x00 }, { 65, 0xff, 0x00, 0x8b }, { 66, 0xff, 0x00, 0xcd }, { 67, 0xff, 0x00, 0xff },
{ 68, 0xff, 0x8b, 0x00 }, { 69, 0xff, 0x8b, 0x8b }, { 70, 0xff, 0x8b, 0xcd }, { 71, 0xff, 0x8b, 0xff },
{ 72, 0xff, 0xcd, 0x00 }, { 73, 0xff, 0xcd, 0x8b }, { 74, 0xff, 0xcd, 0xcd }, { 75, 0xff, 0xcd, 0xff },
{ 76, 0xff, 0xff, 0x00 }, { 77, 0xff, 0xff, 0x8b }, { 78, 0xff, 0xff, 0xcd }, { 79, 0xff, 0xff, 0xff },
{ 80, 0x2e, 0x2e, 0x2e }, { 81, 0x5c, 0x5c, 0x5c }, { 82, 0x73, 0x73, 0x73 }, { 83, 0x8b, 0x8b, 0x8b },
{ 84, 0xa2, 0xa2, 0xa2 }, { 85, 0xb9, 0xb9, 0xb9 }, { 86, 0xd0, 0xd0, 0xd0 }, { 87, 0xe7, 0xe7, 0xe7 },
};
for (int r = 0; r < 256; r++) for (int g = 0; g < 256; g++) for (int b = 0; b < 256; b++) {
int best_metric = 0x7fffffff;
unsigned candidates[10] = { 0 };
int candidates_count = 0;
for (int i = 0; i < 72; i++) {
#define SQ(x) ((x) * (x))
const int cur_metric = SQ(palette[i].r - r) + SQ(palette[i].g - g) + SQ(palette[i].b - b);
#undef SQ
if (cur_metric < best_metric) {
candidates_count = 0;
candidates[candidates_count++] = TERMPAINT_INDEXED_COLOR + palette[i].nr;
best_metric = cur_metric;
} else if (cur_metric == best_metric) {
candidates[candidates_count++] = TERMPAINT_INDEXED_COLOR + palette[i].nr;
}
}
if (candidates_count == 9) {
return false;
}
unsigned res = termpaintp_quantize_color(&terminal, TERMPAINT_RGB_COLOR(r, g, b));
bool ok = false;
for (int i = 0; i < candidates_count; i++) {
if (candidates[i] == res) {
ok = true;
break;
}
}
if (!ok) {
return false;
}
}
return true;
}
static bool termpaintp_test_parse_version(void) {
bool ret = true;
ret &= (termpaintp_parse_version("0.5.0") == 5000);
ret &= (termpaintp_parse_version("0.5.1") == 5001);
ret &= (termpaintp_parse_version("1") == 1000000);
ret &= (termpaintp_parse_version("1.0") == 1000000);
ret &= (termpaintp_parse_version("1.0.0") == 1000000);
ret &= (termpaintp_parse_version("1.7") == 1007000);
ret &= (termpaintp_parse_version("1.7.0") == 1007000);
ret &= (termpaintp_parse_version("1.7.0a") == 1007000);
ret &= (termpaintp_parse_version("1.7a.0") == 1007000);
ret &= (termpaintp_parse_version("1.7.0.1") == 1007000);
ret &= (termpaintp_parse_version("1.7.1") == 1007001);
ret &= (termpaintp_parse_version("1.7.1a") == 1007001);
ret &= (termpaintp_parse_version("1.7a.1") == 1007000);
return ret;
}
// this in internal don't link to this externally
_tERMPAINT_PUBLIC bool termpaintp_test(void) {
bool ret = true;
ret &= termpaintp_test_quantize_to_256();
ret &= termpaintp_test_quantize_to_88();
ret &= termpaintp_test_parse_version();
ret &= termpaintp_mem_ascii_case_insensitive_equals("A", "a", 1);
ret &= !termpaintp_mem_ascii_case_insensitive_equals("[", "{", 1);
return ret;
}
termpaint-0.3.1/termpaint.h 0000664 0000000 0000000 00000051532 14773035472 0015714 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_INCLUDED
#define TERMPAINT_TERMPAINT_INCLUDED
#include
#include
#ifdef __cplusplus
#ifndef _Bool
#define _Bool bool
#endif
#endif
#ifdef __cplusplus
extern "C" {
#define TERMPAINTP_CAST(TYPE, EXPR) static_cast(EXPR)
#else
#define TERMPAINTP_CAST(TYPE, EXPR) (TYPE)(EXPR)
#endif
struct termpaint_attr_;
typedef struct termpaint_attr_ termpaint_attr;
struct termpaint_text_measurement_;
typedef struct termpaint_text_measurement_ termpaint_text_measurement;
struct termpaint_surface_;
typedef struct termpaint_surface_ termpaint_surface;
struct termpaint_terminal_;
typedef struct termpaint_terminal_ termpaint_terminal;
struct termpaint_integration_private_;
typedef struct termpaint_integration_private_ termpaint_integration_private;
typedef struct termpaint_integration_ {
termpaint_integration_private* p;
} termpaint_integration;
_tERMPAINT_PUBLIC void termpaint_integration_init(termpaint_integration *integration,
void (*free)(termpaint_integration *integration),
void (*write)(termpaint_integration *integration, const char *data, int length),
void (*flush)(termpaint_integration *integration));
_tERMPAINT_PUBLIC _Bool termpaint_integration_init_mustcheck(termpaint_integration *integration,
void (*free)(termpaint_integration *integration),
void (*write)(termpaint_integration *integration, const char *data, int length),
void (*flush)(termpaint_integration *integration));
_tERMPAINT_PUBLIC void termpaint_integration_deinit(termpaint_integration *integration);
_tERMPAINT_PUBLIC void termpaint_integration_set_is_bad(termpaint_integration *integration, _Bool (*is_bad)(termpaint_integration *integration));
_tERMPAINT_PUBLIC void termpaint_integration_set_request_callback(termpaint_integration *integration, void (*request_callback)(termpaint_integration *integration));
_tERMPAINT_PUBLIC void termpaint_integration_set_awaiting_response(termpaint_integration *integration, void (*awaiting_response)(termpaint_integration *integration));
_tERMPAINT_PUBLIC void termpaint_integration_set_restore_sequence_updated(termpaint_integration *integration, void (*restore_sequence_updated)(termpaint_integration *integration, const char *data, int length));
_tERMPAINT_PUBLIC void termpaint_integration_set_logging_func(termpaint_integration *integration, void (*logging_func)(termpaint_integration *integration, const char *data, int length));
// getters go here if need arises
_tERMPAINT_PUBLIC termpaint_terminal *termpaint_terminal_new(termpaint_integration *integration);
_tERMPAINT_PUBLIC termpaint_terminal *termpaint_terminal_new_or_nullptr(termpaint_integration *integration);
_tERMPAINT_PUBLIC void termpaint_terminal_free(termpaint_terminal *term);
_tERMPAINT_PUBLIC void termpaint_terminal_free_with_restore(termpaint_terminal *term);
_tERMPAINT_PUBLIC void termpaint_terminal_free_with_restore_and_persistent(termpaint_terminal *term, termpaint_surface *surface);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_terminal_get_surface(termpaint_terminal *term);
_tERMPAINT_PUBLIC void termpaint_terminal_flush(termpaint_terminal *term, _Bool full_repaint);
_tERMPAINT_PUBLIC const char *termpaint_terminal_restore_sequence(const termpaint_terminal *term);
_tERMPAINT_PUBLIC void termpaint_terminal_set_cursor_position(termpaint_terminal *term, int x, int y);
_tERMPAINT_PUBLIC void termpaint_terminal_set_cursor_visible(termpaint_terminal *term, _Bool visible);
#define TERMPAINT_CURSOR_STYLE_TERM_DEFAULT 0
#define TERMPAINT_CURSOR_STYLE_BLOCK 1
#define TERMPAINT_CURSOR_STYLE_UNDERLINE 3
#define TERMPAINT_CURSOR_STYLE_BAR 5
_tERMPAINT_PUBLIC void termpaint_terminal_set_cursor_style(termpaint_terminal *term, int style, _Bool blink);
#define TERMPAINT_COLOR_SLOT_FOREGRUND 10
#define TERMPAINT_COLOR_SLOT_BACKGROUND 11
#define TERMPAINT_COLOR_SLOT_CURSOR 12
_tERMPAINT_PUBLIC _Bool termpaint_terminal_set_color_mustcheck(termpaint_terminal *term, int color_slot, int r, int g, int b);
_tERMPAINT_PUBLIC void termpaint_terminal_set_color(termpaint_terminal *term, int color_slot, int r, int g, int b);
_tERMPAINT_PUBLIC void termpaint_terminal_reset_color(termpaint_terminal *term, int color_slot);
#define TERMPAINT_TITLE_MODE_ENSURE_RESTORE 0
#define TERMPAINT_TITLE_MODE_PREFER_RESTORE 1
_tERMPAINT_PUBLIC void termpaint_terminal_set_title(termpaint_terminal *term, const char* title, int mode);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_set_title_mustcheck(termpaint_terminal *term, const char* title, int mode);
_tERMPAINT_PUBLIC void termpaint_terminal_set_icon_title(termpaint_terminal *term, const char* title, int mode);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_set_icon_title_mustcheck(termpaint_terminal *term, const char* title, int mode);
_tERMPAINT_PUBLIC void termpaint_terminal_bell(termpaint_terminal *term);
#define TERMPAINT_MOUSE_MODE_OFF 0
#define TERMPAINT_MOUSE_MODE_CLICKS 1
#define TERMPAINT_MOUSE_MODE_DRAG 2
#define TERMPAINT_MOUSE_MODE_MOVEMENT 3
_tERMPAINT_PUBLIC void termpaint_terminal_set_mouse_mode(termpaint_terminal *term, int mouse_mode);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_set_mouse_mode_mustcheck(termpaint_terminal *term, int mouse_mode);
_tERMPAINT_PUBLIC void termpaint_terminal_request_focus_change_reports(termpaint_terminal *term, _Bool enabled);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_request_focus_change_reports_mustcheck(termpaint_terminal *term, _Bool enabled);
_tERMPAINT_PUBLIC void termpaint_terminal_request_tagged_paste(termpaint_terminal *term, _Bool enabled);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_request_tagged_paste_mustcheck(termpaint_terminal *term, _Bool enabled);
_tERMPAINT_PUBLIC void termpaint_terminal_callback(termpaint_terminal *term);
_tERMPAINT_PUBLIC void termpaint_terminal_set_raw_input_filter_cb(termpaint_terminal *term, _Bool (*cb)(void *user_data, const char *data, unsigned length, _Bool overflow), void *user_data);
_tERMPAINT_PUBLIC void termpaint_terminal_set_event_cb(termpaint_terminal *term, void (*cb)(void *user_data, termpaint_event* event), void *user_data);
_tERMPAINT_PUBLIC void termpaint_terminal_add_input_data(termpaint_terminal *term, const char *data, unsigned length);
_tERMPAINT_PUBLIC const char* termpaint_terminal_peek_input_buffer(const termpaint_terminal *term);
_tERMPAINT_PUBLIC int termpaint_terminal_peek_input_buffer_length(const termpaint_terminal *term);
// wrapped input option/state setters
_tERMPAINT_PUBLIC void termpaint_terminal_expect_cursor_position_report(termpaint_terminal *term);
_tERMPAINT_PUBLIC void termpaint_terminal_expect_legacy_mouse_reports(termpaint_terminal *term, int s);
_tERMPAINT_PUBLIC void termpaint_terminal_handle_paste(termpaint_terminal *term, _Bool enabled);
_tERMPAINT_PUBLIC void termpaint_terminal_expect_apc_input_sequences(termpaint_terminal *term, _Bool enabled);
_tERMPAINT_PUBLIC void termpaint_terminal_activate_input_quirk(termpaint_terminal *term, int quirk);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_auto_detect(termpaint_terminal *terminal);
enum termpaint_auto_detect_state_enum { termpaint_auto_detect_none,
termpaint_auto_detect_running,
termpaint_auto_detect_done };
_tERMPAINT_PUBLIC enum termpaint_auto_detect_state_enum termpaint_terminal_auto_detect_state(const termpaint_terminal *terminal);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_might_be_supported(const termpaint_terminal *terminal);
_tERMPAINT_PUBLIC void termpaint_terminal_auto_detect_apply_input_quirks(termpaint_terminal *terminal, _Bool backspace_is_x08);
_tERMPAINT_PUBLIC void termpaint_terminal_auto_detect_result_text(const termpaint_terminal *terminal, char *buffer, int buffer_length);
_tERMPAINT_PUBLIC const char *termpaint_terminal_self_reported_name_and_version(const termpaint_terminal *terminal);
_tERMPAINT_PUBLIC void termpaint_terminal_setup_fullscreen(termpaint_terminal *terminal, int width, int height, const char *options);
_tERMPAINT_PUBLIC void termpaint_terminal_setup_inline(termpaint_terminal *terminal, int width, int height, const char *options);
_tERMPAINT_PUBLIC void termpaint_terminal_set_inline(termpaint_terminal *terminal, _Bool enabled);
#define TERMPAINT_CAPABILITY_SAFE_POSITION_REPORT 0
#define TERMPAINT_CAPABILITY_CSI_GREATER 1
#define TERMPAINT_CAPABILITY_CSI_EQUALS 2
#define TERMPAINT_CAPABILITY_CSI_POSTFIX_MOD 3
#define TERMPAINT_CAPABILITY_TITLE_RESTORE 4
#define TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE_BAR 5
#define TERMPAINT_CAPABILITY_CURSOR_SHAPE_OSC50 6
#define TERMPAINT_CAPABILITY_EXTENDED_CHARSET 7
#define TERMPAINT_CAPABILITY_TRUECOLOR_MAYBE_SUPPORTED 8
#define TERMPAINT_CAPABILITY_TRUECOLOR_SUPPORTED 9
#define TERMPAINT_CAPABILITY_88_COLOR 10
#define TERMPAINT_CAPABILITY_CLEARED_COLORING 11
#define TERMPAINT_CAPABILITY_7BIT_ST 12
#define TERMPAINT_CAPABILITY_MAY_TRY_CURSOR_SHAPE 13
#define TERMPAINT_CAPABILITY_MAY_TRY_TAGGED_PASTE 14
#define TERMPAINT_CAPABILITY_CLEARED_COLORING_DEFCOLOR 15
_tERMPAINT_PUBLIC _Bool termpaint_terminal_capable(const termpaint_terminal *terminal, int capability);
_tERMPAINT_PUBLIC void termpaint_terminal_promise_capability(termpaint_terminal *terminal, int capability);
_tERMPAINT_PUBLIC void termpaint_terminal_disable_capability(termpaint_terminal *terminal, int capability);
_tERMPAINT_PUBLIC _Bool termpaint_terminal_should_use_truecolor(termpaint_terminal *terminal);
_tERMPAINT_PUBLIC void termpaint_terminal_pause(termpaint_terminal *term);
_tERMPAINT_PUBLIC void termpaint_terminal_pause_and_persistent(termpaint_terminal *term, termpaint_surface *surface);
_tERMPAINT_PUBLIC void termpaint_terminal_unpause(termpaint_terminal *term);
#define TERMPAINT_LOG_AUTO_DETECT_TRACE (1 << 0)
#define TERMPAINT_LOG_TRACE_RAW_INPUT (1 << 1)
_tERMPAINT_PUBLIC void termpaint_terminal_set_log_mask(termpaint_terminal *term, unsigned mask);
_tERMPAINT_PUBLIC void termpaint_terminal_glitch_on_out_of_memory(termpaint_terminal *term);
_tERMPAINT_PUBLIC termpaint_attr* termpaint_attr_new(unsigned fg, unsigned bg);
_tERMPAINT_PUBLIC termpaint_attr* termpaint_attr_new_or_nullptr(unsigned fg, unsigned bg);
_tERMPAINT_PUBLIC termpaint_attr* termpaint_attr_clone(const termpaint_attr* attr);
_tERMPAINT_PUBLIC termpaint_attr* termpaint_attr_clone_or_nullptr(const termpaint_attr* attr);
_tERMPAINT_PUBLIC void termpaint_attr_free(termpaint_attr* attr);
_tERMPAINT_PUBLIC void termpaint_attr_set_fg(termpaint_attr* attr, unsigned fg);
_tERMPAINT_PUBLIC void termpaint_attr_set_bg(termpaint_attr* attr, unsigned bg);
_tERMPAINT_PUBLIC void termpaint_attr_set_deco(termpaint_attr* attr, unsigned deco_color);
_tERMPAINT_PUBLIC void termpaint_attr_set_patch(termpaint_attr* attr, _Bool optimize, const char *setup, const char * cleanup);
_tERMPAINT_PUBLIC _Bool termpaint_attr_set_patch_mustcheck(termpaint_attr* attr, _Bool optimize, const char *setup, const char * cleanup);
#define TERMPAINT_DEFAULT_COLOR 0x0000000
#define TERMPAINT_NAMED_COLOR 0x2100000
#define TERMPAINT_COLOR_BLACK TERMPAINT_NAMED_COLOR + 0
#define TERMPAINT_COLOR_RED TERMPAINT_NAMED_COLOR + 1
#define TERMPAINT_COLOR_GREEN TERMPAINT_NAMED_COLOR + 2
#define TERMPAINT_COLOR_YELLOW TERMPAINT_NAMED_COLOR + 3
#define TERMPAINT_COLOR_BLUE TERMPAINT_NAMED_COLOR + 4
#define TERMPAINT_COLOR_MAGENTA TERMPAINT_NAMED_COLOR + 5
#define TERMPAINT_COLOR_CYAN TERMPAINT_NAMED_COLOR + 6
#define TERMPAINT_COLOR_LIGHT_GREY TERMPAINT_NAMED_COLOR + 7
#define TERMPAINT_COLOR_DARK_GREY TERMPAINT_NAMED_COLOR + 8
#define TERMPAINT_COLOR_BRIGHT_RED TERMPAINT_NAMED_COLOR + 9
#define TERMPAINT_COLOR_BRIGHT_GREEN TERMPAINT_NAMED_COLOR + 10
#define TERMPAINT_COLOR_BRIGHT_YELLOW TERMPAINT_NAMED_COLOR + 11
#define TERMPAINT_COLOR_BRIGHT_BLUE TERMPAINT_NAMED_COLOR + 12
#define TERMPAINT_COLOR_BRIGHT_MAGENTA TERMPAINT_NAMED_COLOR + 13
#define TERMPAINT_COLOR_BRIGHT_CYAN TERMPAINT_NAMED_COLOR + 14
#define TERMPAINT_COLOR_WHITE TERMPAINT_NAMED_COLOR + 15
#define TERMPAINT_INDEXED_COLOR 0x2200000
#define TERMPAINT_RGB_COLOR_OFFSET 0x1000000
#define TERMPAINT_RGB_COLOR(r, g, b) (TERMPAINT_RGB_COLOR_OFFSET | (TERMPAINTP_CAST(unsigned,r) << 16) | (TERMPAINTP_CAST(unsigned, g) << 8) | TERMPAINTP_CAST(unsigned, b))
#define TERMPAINT_STYLE_BOLD (1<<0)
#define TERMPAINT_STYLE_ITALIC (1<<1)
#define TERMPAINT_STYLE_BLINK (1<<4)
#define TERMPAINT_STYLE_OVERLINE (1<<5)
#define TERMPAINT_STYLE_INVERSE (1<<6)
#define TERMPAINT_STYLE_STRIKE (1<<7)
#define TERMPAINT_STYLE_UNDERLINE (1<<16)
#define TERMPAINT_STYLE_UNDERLINE_DBL (1<<17)
#define TERMPAINT_STYLE_UNDERLINE_CURLY (1<<18)
_tERMPAINT_PUBLIC void termpaint_attr_set_style(termpaint_attr* attr, int bits);
_tERMPAINT_PUBLIC void termpaint_attr_unset_style(termpaint_attr* attr, int bits);
_tERMPAINT_PUBLIC void termpaint_attr_reset_style(termpaint_attr* attr);
#define TERMPAINT_ERASED "\x7f"
_tERMPAINT_PUBLIC termpaint_surface *termpaint_terminal_new_surface(termpaint_terminal *term, int width, int height);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_terminal_new_surface_or_nullptr(termpaint_terminal *term, int width, int height);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_surface_new_surface(termpaint_surface *surface, int width, int height);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_surface_new_surface_or_nullptr(termpaint_surface *surface, int width, int height);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_surface_duplicate(termpaint_surface *surface);
_tERMPAINT_PUBLIC void termpaint_surface_free(termpaint_surface *surface);
_tERMPAINT_PUBLIC void termpaint_surface_resize(termpaint_surface *surface, int width, int height);
_tERMPAINT_PUBLIC _Bool termpaint_surface_resize_mustcheck(termpaint_surface *surface, int width, int height);
_tERMPAINT_PUBLIC int termpaint_surface_width(const termpaint_surface *surface);
_tERMPAINT_PUBLIC int termpaint_surface_height(const termpaint_surface *surface);
_tERMPAINT_PUBLIC int termpaint_surface_char_width(const termpaint_surface *surface, int codepoint);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_colors(termpaint_surface *surface, int x, int y, const char *string, int fg, int bg);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_len_colors(termpaint_surface *surface, int x, int y, const char *string, int len, int fg, int bg);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_colors_clipped(termpaint_surface *surface, int x, int y, const char *string, int fg, int bg, int clip_x0, int clip_x1);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_len_colors_clipped(termpaint_surface *surface, int x, int y, const char *string, int len, int fg, int bg, int clip_x0, int clip_x1);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_attr(termpaint_surface *surface, int x, int y, const char *string, const termpaint_attr *attr);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_len_attr(termpaint_surface *surface, int x, int y, const char *string, int len, const termpaint_attr *attr);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_attr_clipped(termpaint_surface *surface, int x, int y, const char *string, const termpaint_attr *attr, int clip_x0, int clip_x1);
_tERMPAINT_PUBLIC void termpaint_surface_write_with_len_attr_clipped(termpaint_surface *surface, int x, int y, const char *string, int len, const termpaint_attr *attr, int clip_x0, int clip_x1);
_tERMPAINT_PUBLIC void termpaint_surface_clear(termpaint_surface *surface, int fg, int bg);
_tERMPAINT_PUBLIC void termpaint_surface_clear_with_char(termpaint_surface *surface, int fg, int bg, int codepoint);
_tERMPAINT_PUBLIC void termpaint_surface_clear_with_attr(termpaint_surface *surface, const termpaint_attr *attr);
_tERMPAINT_PUBLIC void termpaint_surface_clear_with_attr_char(termpaint_surface *surface, const termpaint_attr *attr, int codepoint);
_tERMPAINT_PUBLIC void termpaint_surface_clear_rect(termpaint_surface *surface, int x, int y, int width, int height, int fg, int bg);
_tERMPAINT_PUBLIC void termpaint_surface_clear_rect_with_char(termpaint_surface *surface, int x, int y, int width, int height, int fg, int bg, int codepoint);
_tERMPAINT_PUBLIC void termpaint_surface_clear_rect_with_attr(termpaint_surface *surface, int x, int y, int width, int height, const termpaint_attr *attr);
_tERMPAINT_PUBLIC void termpaint_surface_clear_rect_with_attr_char(termpaint_surface *surface, int x, int y, int width, int height, const termpaint_attr *attr, int codepoint);
_tERMPAINT_PUBLIC void termpaint_surface_set_fg_color(const termpaint_surface *surface, int x, int y, unsigned fg);
_tERMPAINT_PUBLIC void termpaint_surface_set_bg_color(const termpaint_surface *surface, int x, int y, unsigned bg);
_tERMPAINT_PUBLIC void termpaint_surface_set_deco_color(const termpaint_surface *surface, int x, int y, unsigned deco_color);
_tERMPAINT_PUBLIC void termpaint_surface_set_softwrap_marker(termpaint_surface *surface, int x, int y, _Bool state);
#define TERMPAINT_COPY_NO_TILE 0
#define TERMPAINT_COPY_TILE_PRESERVE -1
#define TERMPAINT_COPY_TILE_PUT 1
_tERMPAINT_PUBLIC void termpaint_surface_copy_rect(termpaint_surface *src_surface, int x, int y, int width, int height,
termpaint_surface *dst_surface, int dst_x, int dst_y,
int tile_left, int tile_right);
_tERMPAINT_PUBLIC void termpaint_surface_tint(termpaint_surface *surface,
void (*recolor)(void *user_data, unsigned *fg, unsigned *bg, unsigned *deco),
void *user_data);
_tERMPAINT_PUBLIC unsigned termpaint_surface_peek_fg_color(const termpaint_surface *surface, int x, int y);
_tERMPAINT_PUBLIC unsigned termpaint_surface_peek_bg_color(const termpaint_surface *surface, int x, int y);
_tERMPAINT_PUBLIC unsigned termpaint_surface_peek_deco_color(const termpaint_surface *surface, int x, int y);
_tERMPAINT_PUBLIC int termpaint_surface_peek_style(const termpaint_surface *surface, int x, int y);
_tERMPAINT_PUBLIC void termpaint_surface_peek_patch(const termpaint_surface *surface, int x, int y, const char **setup, const char **cleanup, _Bool *optimize);
_tERMPAINT_PUBLIC const char *termpaint_surface_peek_text(const termpaint_surface *surface, int x, int y, int *len, int *left, int *right);
_tERMPAINT_PUBLIC _Bool termpaint_surface_peek_softwrap_marker(const termpaint_surface *surface, int x, int y);
_tERMPAINT_PUBLIC _Bool termpaint_surface_same_contents(const termpaint_surface *surface1, const termpaint_surface *surface2);
_tERMPAINT_PUBLIC termpaint_text_measurement* termpaint_text_measurement_new(const termpaint_surface *surface);
_tERMPAINT_PUBLIC termpaint_text_measurement* termpaint_text_measurement_new_or_nullptr(const termpaint_surface *surface);
_tERMPAINT_PUBLIC void termpaint_text_measurement_free(termpaint_text_measurement *m);
_tERMPAINT_PUBLIC void termpaint_text_measurement_reset(termpaint_text_measurement *m);
_tERMPAINT_PUBLIC int termpaint_text_measurement_pending_ref(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC int termpaint_text_measurement_last_codepoints(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC int termpaint_text_measurement_last_clusters(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC int termpaint_text_measurement_last_width(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC int termpaint_text_measurement_last_ref(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC int termpaint_text_measurement_limit_codepoints(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC void termpaint_text_measurement_set_limit_codepoints(termpaint_text_measurement *m, int new_value);
_tERMPAINT_PUBLIC int termpaint_text_measurement_limit_clusters(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC void termpaint_text_measurement_set_limit_clusters(termpaint_text_measurement *m, int new_value);
_tERMPAINT_PUBLIC int termpaint_text_measurement_limit_width(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC void termpaint_text_measurement_set_limit_width(termpaint_text_measurement *m, int new_value);
_tERMPAINT_PUBLIC int termpaint_text_measurement_limit_ref(const termpaint_text_measurement *m);
_tERMPAINT_PUBLIC void termpaint_text_measurement_set_limit_ref(termpaint_text_measurement *m, int new_value);
#define TERMPAINT_MEASURE_LIMIT_REACHED 1
#define TERMPAINT_MEASURE_NEW_CLUSTER 2
_tERMPAINT_PUBLIC int termpaint_text_measurement_feed_codepoint(termpaint_text_measurement *m, int ch, int ref_adjust);
_tERMPAINT_PUBLIC _Bool /* reached limit */ termpaint_text_measurement_feed_utf32(termpaint_text_measurement *m, const uint32_t *chars, int length, _Bool final);
_tERMPAINT_PUBLIC _Bool /* reached limit */ termpaint_text_measurement_feed_utf16(termpaint_text_measurement *m, const uint16_t *code_units, int length, _Bool final);
_tERMPAINT_PUBLIC _Bool /* reached limit */ termpaint_text_measurement_feed_utf8(termpaint_text_measurement *m, const char *code_units, int length, _Bool final);
#ifdef __cplusplus
}
#endif
#endif
termpaint-0.3.1/termpaint.symver 0000664 0000000 0000000 00000020703 14773035472 0017006 0 ustar 00root root 0000000 0000000 TERMPAINT_0.3 { global:
termpaint_attr_clone;
termpaint_attr_clone_or_nullptr;
termpaint_attr_free;
termpaint_attr_new;
termpaint_attr_new_or_nullptr;
termpaint_attr_reset_style;
termpaint_attr_set_bg;
termpaint_attr_set_deco;
termpaint_attr_set_fg;
termpaint_attr_set_patch;
termpaint_attr_set_patch_mustcheck;
termpaint_attr_set_style;
termpaint_attr_unset_style;
termpaint_input_activate_quirk;
termpaint_input_add_data;
termpaint_input_arrow_down;
termpaint_input_arrow_left;
termpaint_input_arrow_right;
termpaint_input_arrow_up;
termpaint_input_backspace;
termpaint_input_context_menu;
termpaint_input_delete;
termpaint_input_end;
termpaint_input_enter;
termpaint_input_escape;
termpaint_input_expect_apc_sequences;
termpaint_input_expect_cursor_position_report;
termpaint_input_expect_legacy_mouse_reports;
termpaint_input_f10;
termpaint_input_f11;
termpaint_input_f12;
termpaint_input_f1;
termpaint_input_f2;
termpaint_input_f3;
termpaint_input_f4;
termpaint_input_f5;
termpaint_input_f6;
termpaint_input_f7;
termpaint_input_f8;
termpaint_input_f9;
termpaint_input_focus_in;
termpaint_input_focus_out;
termpaint_input_free;
termpaint_input_handle_paste;
termpaint_input_home;
termpaint_input_i_resync;
termpaint_input_insert;
termpaint_input_new;
termpaint_input_new_or_nullptr;
termpaint_input_numpad0;
termpaint_input_numpad1;
termpaint_input_numpad2;
termpaint_input_numpad3;
termpaint_input_numpad4;
termpaint_input_numpad5;
termpaint_input_numpad6;
termpaint_input_numpad7;
termpaint_input_numpad8;
termpaint_input_numpad9;
termpaint_input_numpad_add;
termpaint_input_numpad_decimal;
termpaint_input_numpad_divide;
termpaint_input_numpad_enter;
termpaint_input_numpad_multiply;
termpaint_input_numpad_subtract;
termpaint_input_page_down;
termpaint_input_page_up;
termpaint_input_paste_begin;
termpaint_input_paste_end;
termpaint_input_peek_buffer;
termpaint_input_peek_buffer_length;
termpaint_input_set_event_cb;
termpaint_input_set_raw_filter_cb;
termpaint_input_space;
termpaint_input_tab;
termpaint_integration_deinit;
termpaint_integration_init;
termpaint_integration_init_mustcheck;
termpaint_integration_set_awaiting_response;
termpaint_integration_set_is_bad;
termpaint_integration_set_logging_func;
termpaint_integration_set_request_callback;
termpaint_integration_set_restore_sequence_updated;
termpaint_surface_char_width;
termpaint_surface_clear;
termpaint_surface_clear_rect;
termpaint_surface_clear_rect_with_attr;
termpaint_surface_clear_rect_with_attr_char;
termpaint_surface_clear_rect_with_char;
termpaint_surface_clear_with_attr;
termpaint_surface_clear_with_attr_char;
termpaint_surface_clear_with_char;
termpaint_surface_copy_rect;
termpaint_surface_duplicate;
termpaint_surface_free;
termpaint_surface_height;
termpaint_surface_new_surface;
termpaint_surface_new_surface_or_nullptr;
termpaint_surface_peek_bg_color;
termpaint_surface_peek_deco_color;
termpaint_surface_peek_fg_color;
termpaint_surface_peek_patch;
termpaint_surface_peek_softwrap_marker;
termpaint_surface_peek_style;
termpaint_surface_peek_text;
termpaint_surface_resize;
termpaint_surface_resize_mustcheck;
termpaint_surface_same_contents;
termpaint_surface_set_bg_color;
termpaint_surface_set_deco_color;
termpaint_surface_set_fg_color;
termpaint_surface_set_softwrap_marker;
termpaint_surface_tint;
termpaint_surface_width;
termpaint_surface_write_with_attr;
termpaint_surface_write_with_attr_clipped;
termpaint_surface_write_with_colors;
termpaint_surface_write_with_colors_clipped;
termpaint_surface_write_with_len_attr;
termpaint_surface_write_with_len_attr_clipped;
termpaint_surface_write_with_len_colors;
termpaint_surface_write_with_len_colors_clipped;
termpaint_terminal_activate_input_quirk;
termpaint_terminal_add_input_data;
termpaint_terminal_auto_detect;
termpaint_terminal_auto_detect_apply_input_quirks;
termpaint_terminal_auto_detect_result_text;
termpaint_terminal_auto_detect_state;
termpaint_terminal_bell;
termpaint_terminal_callback;
termpaint_terminal_capable;
termpaint_terminal_disable_capability;
termpaint_terminal_expect_apc_input_sequences;
termpaint_terminal_expect_cursor_position_report;
termpaint_terminal_expect_legacy_mouse_reports;
termpaint_terminal_flush;
termpaint_terminal_free;
termpaint_terminal_free_with_restore;
termpaint_terminal_get_surface;
termpaint_terminal_glitch_on_out_of_memory;
termpaint_terminal_handle_paste;
termpaint_terminal_might_be_supported;
termpaint_terminal_new;
termpaint_terminal_new_or_nullptr;
termpaint_terminal_new_surface;
termpaint_terminal_new_surface_or_nullptr;
termpaint_terminal_pause;
termpaint_terminal_peek_input_buffer;
termpaint_terminal_peek_input_buffer_length;
termpaint_terminal_promise_capability;
termpaint_terminal_request_focus_change_reports;
termpaint_terminal_request_focus_change_reports_mustcheck;
termpaint_terminal_request_tagged_paste;
termpaint_terminal_request_tagged_paste_mustcheck;
termpaint_terminal_reset_color;
termpaint_terminal_restore_sequence;
termpaint_terminal_self_reported_name_and_version;
termpaint_terminal_set_color;
termpaint_terminal_set_color_mustcheck;
termpaint_terminal_set_cursor_position;
termpaint_terminal_set_cursor_style;
termpaint_terminal_set_cursor_visible;
termpaint_terminal_set_event_cb;
termpaint_terminal_set_icon_title;
termpaint_terminal_set_icon_title_mustcheck;
termpaint_terminal_set_log_mask;
termpaint_terminal_set_mouse_mode;
termpaint_terminal_set_mouse_mode_mustcheck;
termpaint_terminal_set_raw_input_filter_cb;
termpaint_terminal_set_title;
termpaint_terminal_set_title_mustcheck;
termpaint_terminal_setup_fullscreen;
termpaint_terminal_should_use_truecolor;
termpaint_terminal_unpause;
termpaint_text_measurement_feed_codepoint;
termpaint_text_measurement_feed_utf16;
termpaint_text_measurement_feed_utf32;
termpaint_text_measurement_feed_utf8;
termpaint_text_measurement_free;
termpaint_text_measurement_last_clusters;
termpaint_text_measurement_last_codepoints;
termpaint_text_measurement_last_ref;
termpaint_text_measurement_last_width;
termpaint_text_measurement_limit_clusters;
termpaint_text_measurement_limit_codepoints;
termpaint_text_measurement_limit_ref;
termpaint_text_measurement_limit_width;
termpaint_text_measurement_new;
termpaint_text_measurement_new_or_nullptr;
termpaint_text_measurement_pending_ref;
termpaint_text_measurement_reset;
termpaint_text_measurement_set_limit_clusters;
termpaint_text_measurement_set_limit_codepoints;
termpaint_text_measurement_set_limit_ref;
termpaint_text_measurement_set_limit_width;
termpaintx_enable_tk_logging;
termpaintx_fd_set_termios;
termpaintx_fd_terminal_size;
termpaintx_full_integration;
termpaintx_full_integration_apply_input_quirks;
termpaintx_full_integration_available;
termpaintx_full_integration_do_iteration;
termpaintx_full_integration_do_iteration_with_timeout;
termpaintx_full_integration_from_controlling_terminal;
termpaintx_full_integration_from_fd;
termpaintx_full_integration_original_terminal_attributes;
termpaintx_full_integration_set_terminal;
termpaintx_full_integration_setup_terminal_fullscreen;
termpaintx_full_integration_terminal_size;
termpaintx_full_integration_ttyrescue_start;
termpaintx_full_integration_wait_for_ready;
termpaintx_full_integration_wait_for_ready_with_message;
termpaintx_ttyrescue_set_restore_termios;
termpaintx_ttyrescue_start_or_nullptr;
termpaintx_ttyrescue_stop;
termpaintx_ttyrescue_update;
};
TERMPAINT_0.3.1 { global:
termpaint_terminal_free_with_restore_and_persistent;
termpaint_terminal_pause_and_persistent;
termpaint_terminal_set_inline;
termpaint_terminal_setup_inline;
termpaintx_full_integration_from_fds;
termpaintx_full_integration_set_inline;
termpaintx_full_integration_setup_terminal_inline;
};
TERMPAINT_PRIVATE {
global: termpaintp_test;
local: *;
};
termpaint-0.3.1/termpaint_char_width.h 0000664 0000000 0000000 00000004560 14773035472 0020107 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#define NEW_WIDTH(num, width) ((num << 2) | (((unsigned)width) & 3))
#include "charclassification.inc"
#include "charclassification_konsole_2018.inc"
#include "charclassification_konsole_2022.inc"
#undef NEW_WIDTH
typedef struct termpaintp_width_ {
const uint16_t* termpaint_char_width_offsets;
const uint16_t* termpaint_char_width_data;
} termpaintp_width;
static const termpaintp_width termpaintp_char_width_default = {
.termpaint_char_width_offsets = termpaint_char_width_offsets_default,
.termpaint_char_width_data = termpaint_char_width_data_default
};
static const termpaintp_width termpaintp_char_width_konsole2018 = {
.termpaint_char_width_offsets = termpaint_char_width_offsets_konsole_2018,
.termpaint_char_width_data = termpaint_char_width_data_konsole_2018
};
static const termpaintp_width termpaintp_char_width_konsole2022 = {
.termpaint_char_width_offsets = termpaint_char_width_offsets_konsole_2022,
.termpaint_char_width_data = termpaint_char_width_data_konsole_2022
};
static int termpaintp_char_width(const termpaintp_width *table, int ch) {
if (ch >= 0x10ffff) {
// outside of unicode, assume narrow
return 1;
}
const uint16_t* termpaint_char_width_offsets = table->termpaint_char_width_offsets;
const uint16_t* termpaint_char_width_data = table->termpaint_char_width_data;
int low = termpaint_char_width_offsets[ch >> 14];
int high = termpaint_char_width_offsets[(ch >> 14) + 1] - 1;
int search = (ch & 0x3fff) << 2;
while (1) {
if (low == high) {
if ((termpaint_char_width_data[low] & 0xfffc) > search) {
// this is save as each section always starts with data for 0
--low;
}
int val = termpaint_char_width_data[low] & 3;
if (val == 3) {
return -1;
}
return val;
}
int mid = low + (high - low) / 2;
if (termpaint_char_width_data[mid] < search) {
low = mid + 1;
} else {
if ((termpaint_char_width_data[mid] & 0xfffc) == search) {
int val = termpaint_char_width_data[mid] & 3;
if (val == 3) {
return -1;
}
return val;
} else {
high = mid;
}
}
}
}
termpaint-0.3.1/termpaint_compiler.h 0000664 0000000 0000000 00000002701 14773035472 0017600 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_COMPILER_INCLUDED
#define TERMPAINT_TERMPAINT_COMPILER_INCLUDED
#include
#if __GNUC__ >= 5
#define BUILTIN_CHECKED_ARITHMETIC_SUPPORTED(x) 1
#else
#ifdef __has_builtin
#define BUILTIN_CHECKED_ARITHMETIC_SUPPORTED(x) __has_builtin(x)
#endif
#endif
#ifndef BUILTIN_CHECKED_ARITHMETIC_SUPPORTED
#define BUILTIN_CHECKED_ARITHMETIC_SUPPORTED(x) 0
#endif
static inline _Bool termpaint_smul_overflow(int a, int b, int* res) {
#if BUILTIN_CHECKED_ARITHMETIC_SUPPORTED(__builtin_smul_overflow)
return __builtin_smul_overflow(a, b, res);
#else
_Static_assert(sizeof(int) < sizeof(unsigned long long), "overflow protection not supported");
*res = (unsigned int)a * (unsigned int)b;
unsigned long long ores = (unsigned long long)a * (unsigned long long)b;
return ores != (unsigned long long)*res;
#endif
}
static inline _Bool termpaint_sadd_overflow(int a, int b, int* res) {
#if BUILTIN_CHECKED_ARITHMETIC_SUPPORTED(__builtin_sadd_overflow)
return __builtin_sadd_overflow(a, b, res);
#else
_Static_assert(sizeof(int) < sizeof(long long), "overflow protection not supported");
long long tmp = (long long)a + (long long)b;
*res = (int)tmp;
return tmp > INT_MAX || tmp < INT_MIN;
#endif
}
#define UNUSED(x) (void)x
#ifdef __GNUC__
#define ATTRIBUTE_PRINTF __attribute__ ((format (printf, 2, 3)))
#else
#define ATTRIBUTE_PRINTF
#endif
#endif
termpaint-0.3.1/termpaint_event.c 0000664 0000000 0000000 00000000101 14773035472 0017072 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#include "termpaint_event.h"
termpaint-0.3.1/termpaint_event.h 0000664 0000000 0000000 00000013760 14773035472 0017116 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_EVENT_INCLUDED
#define TERMPAINT_TERMPAINT_EVENT_INCLUDED
#ifdef __cplusplus
#ifndef _Bool
#define _Bool bool
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__GNUC__) && defined(TERMPAINT_EXPORT_SYMBOLS)
#define _tERMPAINT_PUBLIC __attribute__((visibility("default")))
#else
#define _tERMPAINT_PUBLIC
#endif
_tERMPAINT_PUBLIC const char *termpaint_input_i_resync(void);
// Keys
_tERMPAINT_PUBLIC const char *termpaint_input_enter(void);
_tERMPAINT_PUBLIC const char *termpaint_input_space(void);
_tERMPAINT_PUBLIC const char *termpaint_input_tab(void);
_tERMPAINT_PUBLIC const char *termpaint_input_backspace(void);
_tERMPAINT_PUBLIC const char *termpaint_input_context_menu(void);
_tERMPAINT_PUBLIC const char *termpaint_input_delete(void);
_tERMPAINT_PUBLIC const char *termpaint_input_end(void);
_tERMPAINT_PUBLIC const char *termpaint_input_home(void);
_tERMPAINT_PUBLIC const char *termpaint_input_insert(void);
_tERMPAINT_PUBLIC const char *termpaint_input_page_down(void);
_tERMPAINT_PUBLIC const char *termpaint_input_page_up(void);
_tERMPAINT_PUBLIC const char *termpaint_input_arrow_down(void);
_tERMPAINT_PUBLIC const char *termpaint_input_arrow_left(void);
_tERMPAINT_PUBLIC const char *termpaint_input_arrow_right(void);
_tERMPAINT_PUBLIC const char *termpaint_input_arrow_up(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad_divide(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad_multiply(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad_subtract(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad_add(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad_enter(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad_decimal(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad0(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad1(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad2(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad3(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad4(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad5(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad6(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad7(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad8(void);
_tERMPAINT_PUBLIC const char *termpaint_input_numpad9(void);
_tERMPAINT_PUBLIC const char *termpaint_input_escape(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f1(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f2(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f3(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f4(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f5(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f6(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f7(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f8(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f9(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f10(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f11(void);
_tERMPAINT_PUBLIC const char *termpaint_input_f12(void);
// Misc Events
_tERMPAINT_PUBLIC const char *termpaint_input_focus_in(void);
_tERMPAINT_PUBLIC const char *termpaint_input_focus_out(void);
_tERMPAINT_PUBLIC const char *termpaint_input_paste_begin(void);
_tERMPAINT_PUBLIC const char *termpaint_input_paste_end(void);
#define TERMPAINT_EV_UNKNOWN 0
#define TERMPAINT_EV_CHAR 1
#define TERMPAINT_EV_KEY 2
#define TERMPAINT_EV_AUTO_DETECT_FINISHED 3
#define TERMPAINT_EV_OVERFLOW 4
#define TERMPAINT_EV_INVALID_UTF8 5
#define TERMPAINT_EV_CURSOR_POSITION 6
#define TERMPAINT_EV_MODE_REPORT 7
#define TERMPAINT_EV_COLOR_SLOT_REPORT 8
#define TERMPAINT_EV_REPAINT_REQUESTED 9
#define TERMPAINT_EV_MOUSE 10
#define TERMPAINT_EV_MISC 11
#define TERMPAINT_EV_PALETTE_COLOR_REPORT 12
#define TERMPAINT_EV_PASTE 13
#define TERMPAINT_EV_RAW_PRI_DEV_ATTRIB 100
#define TERMPAINT_EV_RAW_SEC_DEV_ATTRIB 101
#define TERMPAINT_EV_RAW_3RD_DEV_ATTRIB 102
#define TERMPAINT_EV_RAW_DECREQTPARM 103
#define TERMPAINT_EV_RAW_TERM_NAME 104
#define TERMPAINT_EV_RAW_TERMINFO_QUERY_REPLY 105
#define TERMPAINT_MOD_SHIFT 1
#define TERMPAINT_MOD_CTRL 2
#define TERMPAINT_MOD_ALT 4
#define TERMPAINT_MOD_ALTGR 8
#define TERMPAINT_MOUSE_PRESS 1
#define TERMPAINT_MOUSE_RELEASE 2
#define TERMPAINT_MOUSE_MOVE 3
struct termpaint_event_ {
int type;
union {
// EV_CHAR and INVALID_UTF8
struct {
unsigned length;
const char *string;
int modifier;
} c;
// EV_KEY
struct {
unsigned length;
const char *atom;
int modifier;
} key;
// EV_PASTE
struct {
unsigned length;
const char *string;
_Bool initial;
_Bool final;
} paste;
// EV_MOUSE
struct {
int x;
int y;
int raw_btn_and_flags;
int action; // TERMPAINT_MOUSE_*
int button; // button == 3 means release with unknown button
int modifier;
} mouse;
// EV_MISC
struct {
unsigned length;
const char *atom;
} misc;
// EV_CURSOR_POSITION
struct {
int x;
int y;
_Bool safe;
} cursor_position;
// EV_MODE_REPORT
struct {
int number;
int kind;
int status;
} mode;
// TERMPAINT_EV_RAW_SEC_DEV_ATTRIB, etc
struct {
unsigned length;
const char *string;
} raw;
// TERMPAINT_EV_COLOR_SLOT_REPORT
struct {
int slot;
const char *color;
unsigned length;
} color_slot_report;
// TERMPAINT_EV_PALETTE_COLOR_REPORT
struct {
int color_index;
const char *color_desc;
unsigned length;
} palette_color_report;
};
};
typedef struct termpaint_event_ termpaint_event;
#ifdef __cplusplus
}
#endif
#endif
termpaint-0.3.1/termpaint_hash.h 0000664 0000000 0000000 00000013522 14773035472 0016714 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_HASH_INCLUDED
#define TERMPAINT_TERMPAINT_HASH_INCLUDED
#include
#include
#include
// internal header, not api or abi stable
// pointers to this are stable as long as the item is kept in the hash
typedef struct termpaint_hash_item_ {
unsigned char* text;
bool unused;
struct termpaint_hash_item_ *next;
} termpaint_hash_item;
typedef struct termpaint_hash_ {
int count;
int allocated;
termpaint_hash_item** buckets;
int item_size;
void (*gc_mark_cb)(struct termpaint_hash_*);
void (*destroy_cb)(struct termpaint_hash_item_*);
} termpaint_hash;
static uint32_t termpaintp_hash_fnv1a(const unsigned char* text) {
uint32_t hash = 2166136261;
for (; *text; ++text) {
hash = hash ^ *text;
hash = hash * 16777619;
}
return hash;
}
static bool termpaintp_hash_grow(termpaint_hash* p) {
int old_allocated = p->allocated;
termpaint_hash_item** old_buckets = p->buckets;
p->allocated *= 2;
p->buckets = (termpaint_hash_item**)calloc(p->allocated, sizeof(*p->buckets));
if (!p->buckets) {
p->allocated = old_allocated;
p->buckets = old_buckets;
return false;
}
for (int i = 0; i < old_allocated; i++) {
termpaint_hash_item* item_it = old_buckets[i];
while (item_it) {
termpaint_hash_item* item = item_it;
item_it = item->next;
uint32_t bucket = termpaintp_hash_fnv1a(item->text) % p->allocated;
item->next = p->buckets[bucket];
p->buckets[bucket] = item;
}
}
free(old_buckets);
return true;
}
static int termpaintp_hash_gc(termpaint_hash* p) {
if (!p->gc_mark_cb) {
return 0;
}
int items_removed = 0;
for (int i = 0; i < p->allocated; i++) {
termpaint_hash_item* item_it = p->buckets[i];
while (item_it) {
item_it->unused = true;
item_it = item_it->next;
}
}
p->gc_mark_cb(p);
for (int i = 0; i < p->allocated; i++) {
termpaint_hash_item** prev_ptr = &p->buckets[i];
termpaint_hash_item* item = *prev_ptr;
while (item) {
termpaint_hash_item* old = item;
if (item->unused) {
*prev_ptr = item->next;
} else {
prev_ptr = &item->next;
}
item = item->next;
if (old->unused) {
--p->count;
if (p->destroy_cb) {
p->destroy_cb(old);
}
free(old->text);
free(old);
++items_removed;
}
}
}
return items_removed;
}
static void* termpaintp_hash_ensure(termpaint_hash* p, const unsigned char* text) {
if (!p->allocated) {
p->allocated = 32;
p->buckets = (termpaint_hash_item**)calloc(p->allocated, sizeof(termpaint_hash_item*));
if (!p->buckets) {
p->allocated = 0;
return NULL;
}
}
uint32_t bucket = termpaintp_hash_fnv1a(text) % p->allocated;
if (p->buckets[bucket]) {
termpaint_hash_item* item = p->buckets[bucket];
termpaint_hash_item* prev = item;
while (item) {
prev = item;
if (strcmp((const char*)text, (char*)item->text) == 0) {
return item;
}
item = item->next;
}
if (p->allocated / 2 <= p->count) {
if (termpaintp_hash_gc(p) == 0) {
if (!termpaintp_hash_grow(p)) {
return NULL;
}
}
// either termpaintp_hash_gc or termpaintp_hash_grow have invalidated `prev` but now capacity is free
return termpaintp_hash_ensure(p, text);
} else {
item = (termpaint_hash_item*)calloc(1, p->item_size);
if (!item) {
return NULL;
}
item->text = (unsigned char*)strdup((const char*)text);
if (!item->text) {
free(item);
return NULL;
}
prev->next = item;
p->count++;
return item;
}
} else {
if (p->allocated / 2 <= p->count && termpaintp_hash_gc(p) == 0) {
if (!termpaintp_hash_grow(p)) {
return NULL;
}
return termpaintp_hash_ensure(p, text);
} else {
termpaint_hash_item* item = (termpaint_hash_item*)calloc(1, p->item_size);
if (!item) {
return NULL;
}
item->text = (unsigned char*)strdup((const char*)text);
if (!item->text) {
free(item);
return NULL;
}
p->count++;
p->buckets[bucket] = item;
return item;
}
}
}
static void* termpaintp_hash_get(termpaint_hash* p, const unsigned char* text) {
if (!p->allocated) {
return NULL;
}
uint32_t bucket = termpaintp_hash_fnv1a(text) % p->allocated;
if (p->buckets[bucket]) {
termpaint_hash_item* item = p->buckets[bucket];
while (item) {
if (strcmp((const char*)text, (char*)item->text) == 0) {
return item;
}
item = item->next;
}
}
return NULL;
}
static void termpaintp_hash_destroy(termpaint_hash* p) {
for (int i = 0; i < p->allocated; i++) {
termpaint_hash_item* item = p->buckets[i];
while (item) {
termpaint_hash_item* old = item;
item = item->next;
if (p->destroy_cb) {
p->destroy_cb(old);
}
free(old->text);
free(old);
}
}
free(p->buckets);
p->buckets = (termpaint_hash_item**)0;
p->allocated = 0;
p->count = 0;
}
#endif
termpaint-0.3.1/termpaint_image.cpp 0000664 0000000 0000000 00000042174 14773035472 0017413 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#include "termpaint_image.h"
#include
#include
#include
#ifndef BUNDLED_PICOJSON
#include "picojson.h"
#else
#include "third-party/picojson.h"
#endif
#include
static const char *const names[16] = {
"black",
"red",
"green",
"yellow",
"blue",
"magenta",
"cyan",
"white",
"bright black",
"bright red",
"bright green",
"bright yellow",
"bright blue",
"bright magenta",
"bright cyan",
"bright white",
};
namespace {
struct FileWriter {
FILE *file;
};
void write_string(FileWriter *w, const char *s) {
fputs(s, w->file);
}
void write_char(FileWriter *w, int c) {
putc(c, w->file);
}
struct StringWriter {
std::string data;
};
void write_string(StringWriter *w, const char *s) {
w->data += s;
}
void write_char(StringWriter *w, int c) {
w->data += c;
}
template
void write_printf(WRITER *w, const char *format, ...) {
char buff[100];
va_list aptr;
va_start(aptr, format);
int len = vsnprintf(buff, sizeof(buff), format, aptr);
va_end(aptr);
if (len < 0) {
abort();
}
if (len < static_cast(sizeof(buff)) - 1) {
write_string(w, buff);
} else {
char *p = (char*)malloc(len + 1);
if (!p) {
abort();
}
va_start(aptr, format);
int res = vsnprintf(p, len + 1, format, aptr);
if (res < 0) {
abort();
}
va_end(aptr);
write_string(w, p);
free(p);
}
}
template
static void print_color(WRITER* f, const char* name, unsigned color) {
if (color != TERMPAINT_DEFAULT_COLOR) {
write_printf(f, ", \"%s\": \"", name);
if ((color & 0xff000000) == TERMPAINT_RGB_COLOR_OFFSET) {
write_printf(f, "#%02x%02x%02x\"", (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
} else if (TERMPAINT_NAMED_COLOR <= color && TERMPAINT_NAMED_COLOR + 15 >= color) {
write_printf(f, "%s\"", names[color & 0xf]);
} else if (TERMPAINT_INDEXED_COLOR <= color && TERMPAINT_INDEXED_COLOR + 255 >= color) {
write_printf(f, "%i\"", color & 0xff);
}
}
}
template
static int print_style(WRITER* f, int style, const char* name, int flag) {
if (style & flag) {
style &= ~flag;
write_printf(f, ", \"%s\": true", name);
}
return style;
}
template
static void print_string(WRITER* f, const char* s_signed, size_t len) {
const unsigned char* s = (const unsigned char*)s_signed;
for (size_t i = 0; i < len;) {
int l = termpaintp_utf8_len(s[i]);
if (i + l > len) {
break;
}
int ch = termpaintp_utf8_decode_from_utf8(s + i, l);
if (s[i] >= 32 && s[i] <= 126 && s[i] != '"' && s[i] != '\\') {
write_char(f, s[i]);
} else {
unsigned both = termpaintp_utf16_split(ch);
write_printf(f, "\\u%04x", both & 0xffff);
if (both > 0xffff) {
write_printf(f, "\\u%04x", both >> 16);
}
}
i += l;
}
}
}
template
static bool termpaintp_image_save_impl(termpaint_surface *surface, WRITER &writer) {
bool ok = true;
const int width = termpaint_surface_width(surface);
const int height = termpaint_surface_height(surface);
write_string(&writer, "{\"termpaint_image\": true,\n");
write_printf(&writer, " \"width\": %d, \"height\": %d, \"version\": 0, \"cells\":[\n", width, height);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
write_printf(&writer, " {\"x\": %d, \"y\": %d,\n", x, y);
write_printf(&writer, " \"t\": \"");
int len, left, right;
const char *text = termpaint_surface_peek_text(surface, x, y, &len, &left, &right);
if (left != x) {
ok = false;
}
if (len != 1 || text[0] != '\x7f') {
print_string(&writer, text, len);
write_string(&writer, "\"");
} else {
write_string(&writer, " \", \"cleared\": true");
}
if (right - left) {
write_printf(&writer, ", \"width\": %i", right - left + 1);
}
print_color(&writer, "fg", termpaint_surface_peek_fg_color(surface, x, y));
print_color(&writer, "bg", termpaint_surface_peek_bg_color(surface, x, y));
print_color(&writer, "deco", termpaint_surface_peek_deco_color(surface, x, y));
int style = termpaint_surface_peek_style(surface, x, y);
style = print_style(&writer, style, "bold", TERMPAINT_STYLE_BOLD);
style = print_style(&writer, style, "italic", TERMPAINT_STYLE_ITALIC);
style = print_style(&writer, style, "blink", TERMPAINT_STYLE_BLINK);
style = print_style(&writer, style, "overline", TERMPAINT_STYLE_OVERLINE);
style = print_style(&writer, style, "inverse", TERMPAINT_STYLE_INVERSE);
style = print_style(&writer, style, "strike", TERMPAINT_STYLE_STRIKE);
style = print_style(&writer, style, "underline", TERMPAINT_STYLE_UNDERLINE);
style = print_style(&writer, style, "double underline", TERMPAINT_STYLE_UNDERLINE_DBL);
style = print_style(&writer, style, "curly underline", TERMPAINT_STYLE_UNDERLINE_CURLY);
if (style != 0) {
ok = false;
}
if (termpaint_surface_peek_softwrap_marker(surface, x, y)) {
write_string(&writer, ", \"x-termpaint-softwrap\": true");
}
const char* setup;
const char* cleanup;
bool optimize;
termpaint_surface_peek_patch(surface, x, y, &setup, &cleanup, &optimize);
if (setup || cleanup) {
write_string(&writer, ", \"patch\": { \"setup\": ");
if (setup) {
write_string(&writer, "\"");
print_string(&writer, setup, strlen(setup));
write_string(&writer, "\"");
} else {
write_string(&writer, "null");
}
write_string(&writer, ", \"cleanup\": ");
if (cleanup) {
write_string(&writer, "\"");
print_string(&writer, cleanup, strlen(cleanup));
write_string(&writer, "\"");
} else {
write_string(&writer, "null");
}
write_printf(&writer, ", \"optimize\": %s}", optimize ? "true" : "false");
}
x = right;
if (x == width-1 && y == height - 1) {
write_string(&writer, "}\n");
} else {
write_string(&writer, "},\n");
}
}
write_string(&writer, "\n");
}
write_string(&writer, "]}\n");
return ok;
}
char *termpaint_image_save_alloc_buffer(termpaint_surface *surface) {
StringWriter writer;
bool res = termpaintp_image_save_impl(surface, writer);
if (!res) {
return nullptr;
} else {
return strdup(writer.data.data());
}
}
void termpaint_image_save_dealloc_buffer(char *buffer) {
free(buffer);
}
bool termpaint_image_save_to_file(termpaint_surface *surface, FILE *file) {
FileWriter writer{file};
return termpaintp_image_save_impl(surface, writer);
}
bool termpaint_image_save(termpaint_surface *surface, const char *name) {
FILE* f = fopen(name, "w");
if (!f) {
return false;
}
bool ret = termpaint_image_save_to_file(surface, f);
if (fclose(f) != 0) {
ret = false;
}
return ret;
}
namespace {
class fread_iterator {
public:
fread_iterator() = default;
fread_iterator(FILE* f) : _f(f), _at_end(false) {
++*this;
}
bool operator==(const fread_iterator& other) const {
return _at_end == other._at_end;
}
void operator++() {
size_t ret;
do {
ret = fread(&_current, 1, 1, _f);
} while (ret == 0 && errno == EINTR);
if (ret < 1) {
_at_end = true;
}
}
char operator*() {
return _current;
}
private:
FILE* _f = nullptr;
bool _at_end = true;
char _current = 0;
};
template
static bool has(const picojson::object& obj, const char* name) {
return obj.count(name) && obj.at(name).is();
}
template
static bool has(const picojson::object& obj, const char* name) {
return obj.count(name) && (obj.at(name).is() || obj.at(name).is());
}
template
static T get(const picojson::object& obj, const char* name) {
return obj.at(name).get();
}
}
static int read_flag(const picojson::object& obj, const char* name, int flag) {
if (has(obj, name) && get(obj, name)) {
return flag;
}
return 0;
}
static unsigned parse_color(const std::string& s) {
if (s.size() == 7 && s[0] == '#') {
int r = 0, g = 0, b = 0;
sscanf(s.data() + 1, "%02x%02x%02x", &r, &g, &b);
return TERMPAINT_RGB_COLOR(r, g, b);
}
for (unsigned i = 0; i < std::extent(); i++) {
if (s == names[i]) {
return TERMPAINT_NAMED_COLOR + i;
}
}
unsigned indexed = 0;
for (unsigned i = 0; i < s.length(); i++) {
if (s[i] < '0' || s[i] > '9') {
break;
}
indexed *= 10;
indexed += (unsigned)s[i] - '0';
if (indexed > 0xff) {
break;
}
if (i + 1 == s.length()) {
return TERMPAINT_INDEXED_COLOR + indexed;
}
}
return TERMPAINT_DEFAULT_COLOR;
}
static bool streq_nullsafe(const char* a, const char* b) {
if (!a && !b) {
return true;
}
if (!a || !b) {
return false;
}
return strcmp(a, b) == 0;
}
static termpaint_surface *termpaintp_image_load_from_value(termpaint_terminal *term, picojson::value& rootValue) {
termpaint_surface *surface = nullptr;
if (!rootValue.is()) {
return nullptr;
}
picojson::object root = rootValue.get();
if (!has(root, "termpaint_image") || !has(root, "version")
|| !has(root, "width") || !has(root, "height")
|| !has(root, "cells")) {
return nullptr;
}
int width = static_cast(get(root, "width"));
int height = static_cast(get(root, "height"));
surface = termpaint_terminal_new_surface(term, width, height);
termpaint_attr* attr = termpaint_attr_new(TERMPAINT_DEFAULT_COLOR, TERMPAINT_DEFAULT_COLOR);
picojson::array cells = get(root, "cells");
for (const auto& cellValue: cells) {
if (!cellValue.is()) {
termpaint_surface_free(surface);
termpaint_attr_free(attr);
return nullptr;
}
picojson::object cell = cellValue.get();
if (!has(cell, "x") || !has(cell, "y")
|| !has(cell, "t")) {
termpaint_surface_free(surface);
termpaint_attr_free(attr);
return nullptr;
}
unsigned fg = TERMPAINT_DEFAULT_COLOR;
if (has(cell, "fg")) {
fg = parse_color(get(cell, "fg"));
}
termpaint_attr_set_fg(attr, fg);
unsigned bg = TERMPAINT_DEFAULT_COLOR;
if (has(cell, "bg")) {
bg = parse_color(get(cell, "bg"));
}
termpaint_attr_set_bg(attr, bg);
unsigned deco = TERMPAINT_DEFAULT_COLOR;
if (has(cell, "deco")) {
deco = parse_color(get(cell, "deco"));
}
termpaint_attr_set_deco(attr, deco);
const char* setup = nullptr;
std::string setup_str;
const char* cleanup = nullptr;
std::string cleanup_str;
bool optimize = true;
if (has(cell, "patch")) {
picojson::object patch = get(cell, "patch");
if (has(patch, "setup")
&& has(patch, "cleanup")
&& has(patch, "optimize")) {
if (has(patch, "setup")) {
setup_str = get(patch, "setup");
setup = setup_str.data();
}
if (has(patch, "cleanup")) {
cleanup_str = get(patch, "cleanup");
cleanup = cleanup_str.data();
}
optimize = get(patch, "optimize");
termpaint_attr_set_patch(attr, optimize, setup, cleanup);
} else {
termpaint_attr_set_patch(attr, false, nullptr, nullptr);
}
} else {
termpaint_attr_set_patch(attr, false, nullptr, nullptr);
}
termpaint_attr_reset_style(attr);
int style = 0;
style |= read_flag(cell, "bold", TERMPAINT_STYLE_BOLD);
style |= read_flag(cell, "italic", TERMPAINT_STYLE_ITALIC);
style |= read_flag(cell, "blink", TERMPAINT_STYLE_BLINK);
style |= read_flag(cell, "overline", TERMPAINT_STYLE_OVERLINE);
style |= read_flag(cell, "inverse", TERMPAINT_STYLE_INVERSE);
style |= read_flag(cell, "strike", TERMPAINT_STYLE_STRIKE);
style |= read_flag(cell, "underline", TERMPAINT_STYLE_UNDERLINE);
style |= read_flag(cell, "double underline", TERMPAINT_STYLE_UNDERLINE_DBL);
style |= read_flag(cell, "curly underline", TERMPAINT_STYLE_UNDERLINE_CURLY);
termpaint_attr_set_style(attr, style);
int x = static_cast(get(cell, "x"));
int y = static_cast(get(cell, "y"));
int width = 1;
if (has(cell, "width")) {
width = static_cast(get(cell, "width"));
}
std::string text = get(cell, "t");
bool erased = has(cell, "cleared") ? get(cell, "cleared") : false;
if (erased) {
text = "\x7f";
}
termpaint_surface_write_with_attr(surface, x, y, text.data(), attr);
if (has(cell, "x-termpaint-softwrap") && get(cell, "x-termpaint-softwrap")) {
termpaint_surface_set_softwrap_marker(surface, x, y, true);
}
{
bool ok = true;
int actual_len;
int actual_left, actual_right;
const char *actual_text = termpaint_surface_peek_text(surface, x, y, &actual_len, &actual_left, &actual_right);
if (actual_text != text || actual_len != static_cast(text.size()) || actual_left != x || actual_right != x + width - 1) {
ok = false;
}
if (fg != termpaint_surface_peek_fg_color(surface, x, y)
|| bg != termpaint_surface_peek_bg_color(surface, x, y)
|| deco != termpaint_surface_peek_deco_color(surface, x, y)
|| style != termpaint_surface_peek_style(surface, x, y)) {
ok = false;
}
const char* actual_setup;
const char* actual_cleanup;
bool actual_optimize;
termpaint_surface_peek_patch(surface, x, y, &actual_setup, &actual_cleanup, &actual_optimize);
if (!streq_nullsafe(actual_setup, setup) || !streq_nullsafe(actual_cleanup, cleanup)
|| actual_optimize != optimize) {
ok = false;
}
if (!ok) {
termpaint_surface_free(surface);
termpaint_attr_free(attr);
return nullptr;
}
}
}
termpaint_attr_free(attr);
return surface;
}
termpaint_surface *termpaint_image_load_from_file(termpaint_terminal *term, FILE *file) {
picojson::value rootValue;
std::string err;
picojson::parse(rootValue, fread_iterator(file), fread_iterator(), &err);
if (err.size()) {
return nullptr;
}
return termpaintp_image_load_from_value(term, rootValue);
}
termpaint_surface *termpaint_image_load(termpaint_terminal *term, const char *name) {
FILE* f = fopen(name, "r");
if (!f) {
return nullptr;
}
picojson::value rootValue;
std::string err;
picojson::parse(rootValue, fread_iterator(f), fread_iterator(), &err);
fclose(f);
if (err.size()) {
return nullptr;
}
return termpaintp_image_load_from_value(term, rootValue);
}
termpaint_surface *termpaint_image_load_from_buffer(termpaint_terminal *term, char *buffer, int length) {
picojson::value rootValue;
std::string err;
picojson::parse(rootValue, buffer, buffer + length, &err);
if (err.size()) {
return nullptr;
}
return termpaintp_image_load_from_value(term, rootValue);
}
termpaint-0.3.1/termpaint_image.h 0000664 0000000 0000000 00000002101 14773035472 0017042 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_IMAGE_INCLUDED
#define TERMPAINT_TERMPAINT_IMAGE_INCLUDED
#include
#include
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__GNUC__) && defined(TERMPAINT_EXPORT_SYMBOLS)
#define _tERMPAINT_PUBLIC __attribute__((visibility("default")))
#else
#define _tERMPAINT_PUBLIC
#endif
_tERMPAINT_PUBLIC _Bool termpaint_image_save(termpaint_surface *surface, const char* name);
_tERMPAINT_PUBLIC _Bool termpaint_image_save_to_file(termpaint_surface *surface, FILE *file);
_tERMPAINT_PUBLIC char* termpaint_image_save_alloc_buffer(termpaint_surface *surface);
_tERMPAINT_PUBLIC void termpaint_image_save_dealloc_buffer(char *buffer);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_image_load(termpaint_terminal *term, const char *name);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_image_load_from_file(termpaint_terminal *term, FILE *file);
_tERMPAINT_PUBLIC termpaint_surface *termpaint_image_load_from_buffer(termpaint_terminal *term, char *buffer, int length);
#ifdef __cplusplus
}
#endif
#endif
termpaint-0.3.1/termpaint_image.symver 0000664 0000000 0000000 00000000425 14773035472 0020147 0 ustar 00root root 0000000 0000000 TERMPAINT_0.3 { global:
termpaint_image_load;
termpaint_image_load_from_buffer;
termpaint_image_load_from_file;
termpaint_image_save;
termpaint_image_save_alloc_buffer;
termpaint_image_save_dealloc_buffer;
termpaint_image_save_to_file;
local: *;
};
termpaint-0.3.1/termpaint_input.c 0000664 0000000 0000000 00000225134 14773035472 0017127 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#include "termpaint_input.h"
#include
#include
#include
#include
#include // for exit
#include // for debugging prints and debugging data export
#include "termpaint_compiler.h"
#include "termpaint_utf8.h"
/* Known problems:
* * Massivly depends on resync trick. Non resync mode currently no longer supported
* * in modOther ctrl-? strange (utf 8 converter?)
* * needs to detect utf-8 encoded C1 chars? Or maybe that not used in the wild at all?
*/
#ifndef nullptr
#define nullptr ((void*)0)
#endif
#define DEF_ATOM(name, value) \
static const char ATOM_ ## name[] = value; \
const char *termpaint_input_ ## name (void) { return ATOM_ ## name; }
// Naming based on W3C uievents-code spec
DEF_ATOM(enter, "Enter")
DEF_ATOM(space, "Space")
DEF_ATOM(tab, "Tab")
DEF_ATOM(backspace, "Backspace")
DEF_ATOM(context_menu, "ContextMenu")
DEF_ATOM(delete, "Delete")
DEF_ATOM(end, "End")
// help omitted
DEF_ATOM(home, "Home")
DEF_ATOM(insert, "Insert")
DEF_ATOM(page_down, "PageDown")
DEF_ATOM(page_up, "PageUp")
DEF_ATOM(arrow_down, "ArrowDown")
DEF_ATOM(arrow_left, "ArrowLeft")
DEF_ATOM(arrow_right, "ArrowRight")
DEF_ATOM(arrow_up, "ArrowUp")
DEF_ATOM(numpad_divide, "NumpadDivide")
DEF_ATOM(numpad_multiply, "NumpadMultiply")
DEF_ATOM(numpad_subtract, "NumpadSubtract")
DEF_ATOM(numpad_add, "NumpadAdd")
DEF_ATOM(numpad_enter, "NumpadEnter")
DEF_ATOM(numpad_decimal, "NumpadDecimal")
DEF_ATOM(numpad0, "Numpad0")
DEF_ATOM(numpad1, "Numpad1")
DEF_ATOM(numpad2, "Numpad2")
DEF_ATOM(numpad3, "Numpad3")
DEF_ATOM(numpad4, "Numpad4")
DEF_ATOM(numpad5, "Numpad5")
DEF_ATOM(numpad6, "Numpad6")
DEF_ATOM(numpad7, "Numpad7")
DEF_ATOM(numpad8, "Numpad8")
DEF_ATOM(numpad9, "Numpad9")
DEF_ATOM(escape, "Escape")
DEF_ATOM(f1, "F1")
DEF_ATOM(f2, "F2")
DEF_ATOM(f3, "F3")
DEF_ATOM(f4, "F4")
DEF_ATOM(f5, "F5")
DEF_ATOM(f6, "F6")
DEF_ATOM(f7, "F7")
DEF_ATOM(f8, "F8")
DEF_ATOM(f9, "F9")
DEF_ATOM(f10, "F10")
DEF_ATOM(f11, "F11")
DEF_ATOM(f12, "F12")
// Misc Events
DEF_ATOM(focus_in, "FocusIn")
DEF_ATOM(focus_out, "FocusOut")
DEF_ATOM(paste_begin, "PasteBegin")
DEF_ATOM(paste_end, "PasteEnd")
DEF_ATOM(i_resync, "i_resync")
#define MOD_CTRL TERMPAINT_MOD_CTRL
#define MOD_ALT TERMPAINT_MOD_ALT
#define MOD_SHIFT TERMPAINT_MOD_SHIFT
#define MOD_ALTGR TERMPAINT_MOD_ALTGR
#define MOD_PRINT (1u << 31)
#define MOD_ENTER (1 << 31 + 1 << 30)
//#define MOD_PRINT (1 << 31)
struct key_mapping_entry_ {
const char *sequence;
const char *atom;
unsigned int modifiers;
};
typedef struct key_mapping_entry_ key_mapping_entry;
#define XTERM_MODS(PREFIX, POSTFIX, ATOM) \
{ PREFIX "2" POSTFIX, ATOM, MOD_SHIFT }, \
{ PREFIX "3" POSTFIX, ATOM, MOD_ALT }, \
{ PREFIX "4" POSTFIX, ATOM, MOD_ALT | MOD_SHIFT }, \
{ PREFIX "5" POSTFIX, ATOM, MOD_CTRL }, \
{ PREFIX "6" POSTFIX, ATOM, MOD_CTRL | MOD_SHIFT }, \
{ PREFIX "7" POSTFIX, ATOM, MOD_CTRL | MOD_ALT }, \
{ PREFIX "8" POSTFIX, ATOM, MOD_CTRL | MOD_ALT | MOD_SHIFT }
// xterm has 2 settings where a '>' is added to the CSI sequences added, support that too
// ESC[>2;3m and ESC[>1;3m
#define XTERM_MODS_GT(STR, POSTFIX, ATOM) \
{ "\033[" STR "2" POSTFIX, ATOM, MOD_SHIFT }, \
{ "\033[>" STR "2" POSTFIX, ATOM, MOD_SHIFT }, \
{ "\033[" STR "3" POSTFIX, ATOM, MOD_ALT }, \
{ "\033[>" STR "3" POSTFIX, ATOM, MOD_ALT }, \
{ "\033[" STR "4" POSTFIX, ATOM, MOD_ALT | MOD_SHIFT }, \
{ "\033[>" STR "4" POSTFIX, ATOM, MOD_ALT | MOD_SHIFT }, \
{ "\033[" STR "5" POSTFIX, ATOM, MOD_CTRL }, \
{ "\033[>" STR "5" POSTFIX, ATOM, MOD_CTRL }, \
{ "\033[" STR "6" POSTFIX, ATOM, MOD_CTRL | MOD_SHIFT }, \
{ "\033[>" STR "6" POSTFIX, ATOM, MOD_CTRL | MOD_SHIFT }, \
{ "\033[" STR "7" POSTFIX, ATOM, MOD_CTRL | MOD_ALT }, \
{ "\033[>" STR "7" POSTFIX, ATOM, MOD_CTRL | MOD_ALT }, \
{ "\033[" STR "8" POSTFIX, ATOM, MOD_CTRL | MOD_ALT | MOD_SHIFT }, \
{ "\033[>" STR "8" POSTFIX, ATOM, MOD_CTRL | MOD_ALT | MOD_SHIFT }
// keyboard settings to consider:
// xterm:
// xterm.vt100.translations: : insert() --> remove all xterm side keybindings
// xterm.vt100.modifyCursorKeys \in (-1, 0, 1, 2, 3)
// xterm.vt100.modifyFunctionKeys \in (-1, 0, 1, 2, 3)
// xterm.vt100.modifyKeyboard ??
// xterm.vt100.modifyOtherKeys ??
// xterm.vt100.oldXtermFKeys ??
//
// urxvt: urxvt --perl-ext-common "" --perl-ext "" ++iso14755 -keysym.Insert "builtin-string:" -keysym.Prior "builtin-string:" -keysym.Next "builtin-string:" -keysym.C-M-v "builtin-string:" -keysym.C-M-c "builtin-string:"
// Modes:
// ?1
// ?66 keypad mapping changes
// ?67
// ?1035
// ?1036
// ?1039
// ?1050 ???
// ?1051 ???
// ?1052 ???
// ?1053 ???
// ?1060 ???
// ?1061 ???
static const key_mapping_entry key_mapping_table[] = {
{ "\x0d", ATOM_enter, 0 }, // also ctrl-m in traditional mode
{ "\033\x0d", ATOM_enter, MOD_ALT },
XTERM_MODS("\033[27;", ";13~", ATOM_enter), // modifiy other keys mode
XTERM_MODS("\033[13;", "u", ATOM_enter), // modifiy other keys mode
{ "\x09", ATOM_tab, 0 }, //also ctrl_i
{ "\033\x09", ATOM_tab, MOD_ALT }, //also ctrl-alt-i
{ "\033[Z", ATOM_tab, MOD_SHIFT }, // xterm, normal mode
XTERM_MODS("\033[27;", ";9~", ATOM_tab), // modifiy other keys mode
XTERM_MODS("\033[9;", "u", ATOM_tab), // modifiy other keys mode
{ " ", ATOM_space, 0 },
{ "\033 ", ATOM_space, MOD_ALT },
// { "\x00", ATOM_SPACE, MOD_CTRL } via special case in code
// { "\033\x00", ATOM_space, MOD_CTRL | MOD_ALT} via special case in code
XTERM_MODS("\033[27;", ";32~", ATOM_space), // modifiy other keys mode
XTERM_MODS("\033[32;", "u", ATOM_space), // modifiy other keys mode
//+ also ctrl-2
{ "\033[29~", ATOM_context_menu, 0 },
// + also shift F4 in linux vt
XTERM_MODS("\033[29;", "~", ATOM_context_menu),
{ "\033[3~", ATOM_delete, 0 },
XTERM_MODS("\033[3;", "~", ATOM_delete),
{ "\033[3$", ATOM_delete, MOD_SHIFT},
{ "\033[3^", ATOM_delete, MOD_CTRL},
{ "\033[3@", ATOM_delete, MOD_CTRL | MOD_SHIFT},
{ "\033\033[3~", ATOM_delete, MOD_ALT },
{ "\033\033[3$", ATOM_delete, MOD_ALT | MOD_SHIFT},
{ "\033\033[3^", ATOM_delete, MOD_CTRL | MOD_ALT},
{ "\033\033[3@", ATOM_delete, MOD_CTRL | MOD_ALT | MOD_SHIFT},
{ "\033[3;1~", ATOM_delete, MOD_ALTGR },
{ "\033[F", ATOM_end, 0},
XTERM_MODS_GT("1;", "F", ATOM_end),
{ "\033OF", ATOM_end, 0},
{ "\033[4~", ATOM_end, 0},
{ "\033[8~", ATOM_end, 0},
{ "\033[8$", ATOM_end, MOD_SHIFT},
{ "\033[8^", ATOM_end, MOD_CTRL},
{ "\033[8@", ATOM_end, MOD_CTRL | MOD_SHIFT},
{ "\033\033[8~", ATOM_end, MOD_ALT},
{ "\033\033[8$", ATOM_end, MOD_ALT | MOD_SHIFT},
{ "\033\033[8^", ATOM_end, MOD_CTRL | MOD_ALT},
{ "\033\033[8@", ATOM_end, MOD_CTRL | MOD_ALT | MOD_SHIFT},
{ "\033[1;1F", ATOM_end, MOD_ALTGR},
{ "\033[H", ATOM_home, 0},
XTERM_MODS_GT("1;", "H", ATOM_home),
{ "\033OH", ATOM_home, 0},
{ "\033[1~", ATOM_home, 0},
{ "\033[7~", ATOM_home, 0},
{ "\033[7$", ATOM_home, MOD_SHIFT},
{ "\033[7^", ATOM_home, MOD_CTRL},
{ "\033[7@", ATOM_home, MOD_CTRL | MOD_SHIFT},
{ "\033\033[7~", ATOM_home, MOD_ALT},
{ "\033\033[7$", ATOM_home, MOD_ALT | MOD_SHIFT},
{ "\033\033[7^", ATOM_home, MOD_CTRL | MOD_ALT},
{ "\033\033[7@", ATOM_home, MOD_CTRL | MOD_ALT | MOD_SHIFT},
{ "\033[1;1H", ATOM_home, MOD_ALTGR},
{ "\033[2~", ATOM_insert, 0},
XTERM_MODS("\033[2;", "~", ATOM_insert),
{ "\033[2$", ATOM_insert, MOD_SHIFT},
{ "\033[2^", ATOM_insert, MOD_CTRL},
{ "\033[2@", ATOM_insert, MOD_CTRL | MOD_SHIFT},
{ "\033\033[2~", ATOM_insert, MOD_ALT},
{ "\033\033[2$", ATOM_insert, MOD_ALT | MOD_SHIFT},
{ "\033\033[2^", ATOM_insert, MOD_CTRL | MOD_ALT},
{ "\033\033[2@", ATOM_insert, MOD_CTRL | MOD_ALT | MOD_SHIFT},
{ "\033[2;1~", ATOM_insert, MOD_ALTGR},
{ "\033[6~", ATOM_page_down, 0},
XTERM_MODS("\033[6;", "~", ATOM_page_down),
{ "\033[6$", ATOM_page_down, MOD_SHIFT},
{ "\033[6^", ATOM_page_down, MOD_CTRL},
{ "\033[6@", ATOM_page_down, MOD_CTRL | MOD_SHIFT},
{ "\033\033[6~", ATOM_page_down, MOD_ALT},
{ "\033\033[6$", ATOM_page_down, MOD_ALT | MOD_SHIFT},
{ "\033\033[6^", ATOM_page_down, MOD_CTRL | MOD_ALT},
{ "\033\033[6@", ATOM_page_down, MOD_CTRL | MOD_ALT | MOD_SHIFT},
{ "\033[6;1~", ATOM_page_down, MOD_ALTGR},
{ "\033[5~", ATOM_page_up, 0},
XTERM_MODS("\033[5;", "~", ATOM_page_up), // shift combinations only available when scroll bindings are removed in xterm
{ "\033[5$", ATOM_page_up, MOD_SHIFT},
{ "\033[5^", ATOM_page_up, MOD_CTRL},
{ "\033[5@", ATOM_page_up, MOD_CTRL | MOD_SHIFT},
{ "\033\033[5~", ATOM_page_up, MOD_ALT},
{ "\033\033[5$", ATOM_page_up, MOD_ALT | MOD_SHIFT},
{ "\033\033[5^", ATOM_page_up, MOD_CTRL | MOD_ALT},
{ "\033\033[5@", ATOM_page_up, MOD_CTRL | MOD_ALT | MOD_SHIFT},
{ "\033[5;1~", ATOM_page_up, MOD_ALTGR},
{ "\033[B", ATOM_arrow_down, 0 },
XTERM_MODS_GT("1;", "B", ATOM_arrow_down),
{ "\033OB", ATOM_arrow_down, 0 },
{ "\033[b", ATOM_arrow_down, MOD_SHIFT },
{ "\033Ob", ATOM_arrow_down, MOD_CTRL },
{ "\033\033[B", ATOM_arrow_down, MOD_ALT },
{ "\033\033[b", ATOM_arrow_down, MOD_ALT | MOD_SHIFT },
{ "\033\033Ob", ATOM_arrow_down, MOD_CTRL | MOD_ALT },
{ "\033[1;1B", ATOM_arrow_down, MOD_ALTGR },
{ "\033[D", ATOM_arrow_left, 0 },
XTERM_MODS_GT("1;", "D", ATOM_arrow_left),
{ "\033OD", ATOM_arrow_left, 0 },
{ "\033[d", ATOM_arrow_left, MOD_SHIFT },
{ "\033Od", ATOM_arrow_left, MOD_CTRL },
{ "\033\033[D", ATOM_arrow_left, MOD_ALT },
{ "\033\033[d", ATOM_arrow_left, MOD_ALT | MOD_SHIFT },
{ "\033\033Od", ATOM_arrow_left, MOD_CTRL | MOD_ALT },
{ "\033[1;1D", ATOM_arrow_left, MOD_ALTGR },
{ "\033[C", ATOM_arrow_right, 0 },
XTERM_MODS_GT("1;", "C", ATOM_arrow_right),
{ "\033OC", ATOM_arrow_right, 0 },
{ "\033[c", ATOM_arrow_right, MOD_SHIFT },
{ "\033Oc", ATOM_arrow_right, MOD_CTRL },
{ "\033\033[C", ATOM_arrow_right, MOD_ALT },
{ "\033\033[c", ATOM_arrow_right, MOD_ALT | MOD_SHIFT },
{ "\033\033Oc", ATOM_arrow_right, MOD_CTRL | MOD_ALT },
{ "\033[1;1C", ATOM_arrow_right, MOD_ALTGR },
{ "\033[A", ATOM_arrow_up, 0 },
XTERM_MODS_GT("1;", "A", ATOM_arrow_up),
{ "\033OA", ATOM_arrow_up, 0 },
{ "\033[a", ATOM_arrow_up, MOD_SHIFT },
{ "\033Oa", ATOM_arrow_up, MOD_CTRL },
{ "\033\033[A", ATOM_arrow_up, MOD_ALT },
{ "\033\033[a", ATOM_arrow_up, MOD_ALT | MOD_SHIFT },
{ "\033\033Oa", ATOM_arrow_up, MOD_CTRL | MOD_ALT },
{ "\033[1;1A", ATOM_arrow_up, MOD_ALTGR },
{ "\033Oo", ATOM_numpad_divide, 0 },
{ "\033\033Oo", ATOM_numpad_divide, MOD_ALT },
XTERM_MODS("\033O", "o", ATOM_numpad_divide), // ctrl-alt (not shifted) not reachable in xterm
{ "\033Oj", ATOM_numpad_multiply, 0 },
{ "\033\033Oj", ATOM_numpad_multiply, MOD_ALT },
XTERM_MODS("\033O", "j", ATOM_numpad_multiply), // ctrl-alt (not shifted) not reachable in xterm
{ "\033Om", ATOM_numpad_subtract, 0 },
{ "\033\033Om", ATOM_numpad_subtract, MOD_ALT },
XTERM_MODS("\033O", "m", ATOM_numpad_subtract), // ctrl-alt (not shifted) not reachable in xterm
{ "\033Ok", ATOM_numpad_add, 0 },
{ "\033\033Ok", ATOM_numpad_add, MOD_ALT },
XTERM_MODS("\033O", "k", ATOM_numpad_add), // ctrl-alt (not shifted) not reachable in xterm
{ "\033OM", ATOM_numpad_enter, 0 },
{ "\033\033OM", ATOM_numpad_enter, MOD_ALT },
XTERM_MODS("\033O", "M", ATOM_numpad_enter),
//{ "\033[3~", ATOM_numpad_decimal, 0 },
//XTERM_MODS("\033[3;", "~", ATOM_numpad_decimal), // shifted combinations produce other codes in xterm
{ "\033O2l", ATOM_numpad_decimal, MOD_SHIFT },
{ "\033O3l", ATOM_numpad_decimal, MOD_ALT },
{ "\033O5l", ATOM_numpad_decimal, MOD_CTRL },
{ "\033O6l", ATOM_numpad_decimal, MOD_CTRL | MOD_SHIFT },
{ "\033O4l", ATOM_numpad_decimal, MOD_ALT | MOD_SHIFT },
{ "\033O7l", ATOM_numpad_decimal, MOD_CTRL | MOD_ALT },
{ "\033O8l", ATOM_numpad_decimal, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Ol", ATOM_numpad_decimal, MOD_ALT },
{ "\033On", ATOM_numpad_decimal, 0 },
{ "\033\033On",ATOM_numpad_decimal, MOD_ALT },
{ "\033O2p", ATOM_numpad0, MOD_SHIFT },
{ "\033O3p", ATOM_numpad0, MOD_ALT },
{ "\033O5p", ATOM_numpad0, MOD_CTRL },
{ "\033O6p", ATOM_numpad0, MOD_CTRL | MOD_SHIFT },
{ "\033O4p", ATOM_numpad0, MOD_ALT | MOD_SHIFT },
{ "\033O7p", ATOM_numpad0, MOD_CTRL | MOD_ALT },
{ "\033O8p", ATOM_numpad0, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Op", ATOM_numpad0, 0 },
{ "\033\033Op",ATOM_numpad0, MOD_ALT },
{ "\033O2q", ATOM_numpad1, MOD_SHIFT },
{ "\033O3q", ATOM_numpad1, MOD_ALT },
{ "\033O5q", ATOM_numpad1, MOD_CTRL },
{ "\033O6q", ATOM_numpad1, MOD_CTRL | MOD_SHIFT },
{ "\033O4q", ATOM_numpad1, MOD_ALT | MOD_SHIFT },
{ "\033O7q", ATOM_numpad1, MOD_CTRL | MOD_ALT },
{ "\033O8q", ATOM_numpad1, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Oq", ATOM_numpad1, 0 },
{ "\033\033Oq",ATOM_numpad1, MOD_ALT },
{ "\033O2r", ATOM_numpad2, MOD_SHIFT },
{ "\033O3r", ATOM_numpad2, MOD_ALT },
{ "\033O5r", ATOM_numpad2, MOD_CTRL },
{ "\033O6r", ATOM_numpad2, MOD_CTRL | MOD_SHIFT },
{ "\033O4r", ATOM_numpad2, MOD_ALT | MOD_SHIFT },
{ "\033O7r", ATOM_numpad2, MOD_CTRL | MOD_ALT },
{ "\033O8r", ATOM_numpad2, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Or", ATOM_numpad2, 0 },
{ "\033\033Or",ATOM_numpad2, MOD_ALT },
{ "\033O2s", ATOM_numpad3, MOD_SHIFT },
{ "\033O3s", ATOM_numpad3, MOD_ALT },
{ "\033O5s", ATOM_numpad3, MOD_CTRL },
{ "\033O6s", ATOM_numpad3, MOD_CTRL | MOD_SHIFT },
{ "\033O4s", ATOM_numpad3, MOD_ALT | MOD_SHIFT },
{ "\033O7s", ATOM_numpad3, MOD_CTRL | MOD_ALT },
{ "\033O8s", ATOM_numpad3, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Os", ATOM_numpad3, 0 },
{ "\033\033Os",ATOM_numpad3, MOD_ALT },
{ "\033O2t", ATOM_numpad4, MOD_SHIFT },
{ "\033O3t", ATOM_numpad4, MOD_ALT },
{ "\033O5t", ATOM_numpad4, MOD_CTRL },
{ "\033O6t", ATOM_numpad4, MOD_CTRL | MOD_SHIFT },
{ "\033O4t", ATOM_numpad4, MOD_ALT | MOD_SHIFT },
{ "\033O7t", ATOM_numpad4, MOD_CTRL | MOD_ALT },
{ "\033O8t", ATOM_numpad4, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Ot", ATOM_numpad4, 0 },
{ "\033\033Ot",ATOM_numpad4, MOD_ALT },
{ "\033O2u", ATOM_numpad5, MOD_SHIFT },
{ "\033O3u", ATOM_numpad5, MOD_ALT },
{ "\033O5u", ATOM_numpad5, MOD_CTRL },
{ "\033O6u", ATOM_numpad5, MOD_CTRL | MOD_SHIFT },
{ "\033O4u", ATOM_numpad5, MOD_ALT | MOD_SHIFT },
{ "\033O7u", ATOM_numpad5, MOD_CTRL | MOD_ALT },
{ "\033O8u", ATOM_numpad5, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Ou", ATOM_numpad5, 0 },
{ "\033\033Ou",ATOM_numpad5, MOD_ALT },
{ "\033[E", ATOM_numpad5, 0 },
XTERM_MODS_GT("1;", "E", ATOM_numpad5),
{ "\033OE", ATOM_numpad5, 0 },
{ "\033[G", ATOM_numpad5, 0 },
{ "\033O2v", ATOM_numpad6, MOD_SHIFT },
{ "\033O3v", ATOM_numpad6, MOD_ALT },
{ "\033O5v", ATOM_numpad6, MOD_CTRL },
{ "\033O6v", ATOM_numpad6, MOD_CTRL | MOD_SHIFT },
{ "\033O4v", ATOM_numpad6, MOD_ALT | MOD_SHIFT },
{ "\033O7v", ATOM_numpad6, MOD_CTRL | MOD_ALT },
{ "\033O8v", ATOM_numpad6, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Ov", ATOM_numpad6, 0 },
{ "\033\033Ov",ATOM_numpad6, MOD_ALT },
{ "\033O2w", ATOM_numpad7, MOD_SHIFT },
{ "\033O3w", ATOM_numpad7, MOD_ALT },
{ "\033O5w", ATOM_numpad7, MOD_CTRL },
{ "\033O6w", ATOM_numpad7, MOD_CTRL | MOD_SHIFT },
{ "\033O4w", ATOM_numpad7, MOD_ALT | MOD_SHIFT },
{ "\033O7w", ATOM_numpad7, MOD_CTRL | MOD_ALT },
{ "\033O8w", ATOM_numpad7, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Ow", ATOM_numpad7, 0 },
{ "\033\033Ow",ATOM_numpad7, MOD_ALT },
{ "\033O2x", ATOM_numpad8, MOD_SHIFT },
{ "\033O3x", ATOM_numpad8, MOD_ALT },
{ "\033O5x", ATOM_numpad8, MOD_CTRL },
{ "\033O6x", ATOM_numpad8, MOD_CTRL | MOD_SHIFT },
{ "\033O4x", ATOM_numpad8, MOD_ALT | MOD_SHIFT },
{ "\033O7x", ATOM_numpad8, MOD_CTRL | MOD_ALT },
{ "\033O8x", ATOM_numpad8, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Ox", ATOM_numpad8, 0 },
{ "\033\033Ox",ATOM_numpad8, MOD_ALT },
{ "\033O2y", ATOM_numpad9, MOD_SHIFT },
{ "\033O3y", ATOM_numpad9, MOD_ALT },
{ "\033O5y", ATOM_numpad9, MOD_CTRL },
{ "\033O6y", ATOM_numpad9, MOD_CTRL | MOD_SHIFT },
{ "\033O4y", ATOM_numpad9, MOD_ALT | MOD_SHIFT },
{ "\033O7y", ATOM_numpad9, MOD_CTRL | MOD_ALT },
{ "\033O8y", ATOM_numpad9, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033Oy", ATOM_numpad9, 0 },
{ "\033\033Oy",ATOM_numpad9, MOD_ALT },
// { "\033", ATOM_escape, }, via special case in code (also Ctrl-[ in traditional mode)
XTERM_MODS("\033[27;", ";27~", ATOM_escape), // modifiy other keys mode
XTERM_MODS("\033[27;", "u", ATOM_escape), // modifiy other keys mode
{ "\033\033", ATOM_escape, MOD_ALT },
{ "\033OP", ATOM_f1, 0 },
XTERM_MODS_GT("1;", "P", ATOM_f1),
XTERM_MODS("\033O", "P", ATOM_f1),
{ "\033[[A", ATOM_f1, 0 },
{ "\033[25~", ATOM_f1, MOD_SHIFT },
{ "\033[25^", ATOM_f1, MOD_CTRL | MOD_SHIFT },
{ "\033\033[25~", ATOM_f1, MOD_ALT | MOD_SHIFT },
{ "\033\033[25^", ATOM_f1, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033O1P", ATOM_f1, MOD_ALTGR },
{ "\033[11~", ATOM_f1, 0 },
{ "\033[11^", ATOM_f1, MOD_CTRL },
{ "\033\033[11~", ATOM_f1, MOD_ALT },
{ "\033\033[11^", ATOM_f1, MOD_CTRL | MOD_ALT },
{ "\033OQ", ATOM_f2, 0 },
XTERM_MODS_GT("1;", "Q", ATOM_f2),
XTERM_MODS("\033O", "Q", ATOM_f2),
{ "\033[[B", ATOM_f2, 0 },
{ "\033[26~", ATOM_f2, MOD_SHIFT },
{ "\033[26^", ATOM_f2, MOD_CTRL | MOD_SHIFT },
{ "\033\033[26~", ATOM_f2, MOD_ALT | MOD_SHIFT },
{ "\033\033[26^", ATOM_f2, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033O1Q", ATOM_f2, MOD_ALTGR },
{ "\033[12~", ATOM_f2, 0 },
{ "\033[12^", ATOM_f2, MOD_CTRL },
{ "\033\033[12~", ATOM_f2, MOD_ALT },
{ "\033\033[12^", ATOM_f2, MOD_CTRL | MOD_ALT },
{ "\033OR", ATOM_f3, 0 },
XTERM_MODS_GT("1;", "R", ATOM_f3),
XTERM_MODS("\033O", "R", ATOM_f3),
{ "\033[[C", ATOM_f3, 0 },
{ "\033[28~", ATOM_f3, MOD_SHIFT },
{ "\033[28^", ATOM_f3, MOD_CTRL | MOD_SHIFT },
{ "\033\033[28~", ATOM_f3, MOD_ALT | MOD_SHIFT },
{ "\033\033[28^", ATOM_f3, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033O1R", ATOM_f3, MOD_ALTGR },
{ "\033[13~", ATOM_f3, 0 },
{ "\033[13^", ATOM_f3, MOD_CTRL },
{ "\033\033[13~", ATOM_f3, MOD_ALT },
{ "\033\033[13^", ATOM_f3, MOD_CTRL | MOD_ALT },
{ "\033OS", ATOM_f4, 0 },
XTERM_MODS_GT("1;", "S", ATOM_f4),
XTERM_MODS("\033O", "S", ATOM_f4),
{ "\033[[D", ATOM_f4, 0 },
{ "\033O1S", ATOM_f4, MOD_ALTGR },
{ "\033[14~", ATOM_f4, 0 },
{ "\033[14^", ATOM_f4, MOD_CTRL },
{ "\033\033[14~", ATOM_f4, MOD_ALT },
{ "\033\033[14^", ATOM_f4, MOD_CTRL | MOD_ALT },
{ "\033[29^", ATOM_f4, MOD_CTRL | MOD_SHIFT },
{ "\033\033[29~", ATOM_f4, MOD_ALT | MOD_SHIFT },
{ "\033\033[29^", ATOM_f4, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033[15~", ATOM_f5, 0 },
{ "\033[15^", ATOM_f5, MOD_CTRL },
{ "\033\033[15~", ATOM_f5, MOD_ALT },
{ "\033\033[15^", ATOM_f5, MOD_CTRL | MOD_ALT },
XTERM_MODS_GT("15;", "~", ATOM_f5),
{ "\033[[E", ATOM_f5, 0 },
{ "\033[31~", ATOM_f5, MOD_SHIFT },
{ "\033[31^", ATOM_f5, MOD_CTRL | MOD_SHIFT },
{ "\033\033[31~", ATOM_f5, MOD_ALT | MOD_SHIFT },
{ "\033\033[31^", ATOM_f5, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033[15;1~", ATOM_f5, MOD_ALTGR },
{ "\033[17~", ATOM_f6, 0 },
{ "\033[17^", ATOM_f6, MOD_CTRL },
{ "\033\033[17~", ATOM_f6, MOD_ALT },
{ "\033\033[17^", ATOM_f6, MOD_CTRL | MOD_ALT },
XTERM_MODS_GT("17;", "~", ATOM_f6),
{ "\033[32~", ATOM_f6, MOD_SHIFT },
{ "\033[32^", ATOM_f6, MOD_CTRL | MOD_SHIFT },
{ "\033\033[32~", ATOM_f6, MOD_ALT | MOD_SHIFT },
{ "\033\033[32^", ATOM_f6, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033[17;1~", ATOM_f6, MOD_ALTGR },
{ "\033[18~", ATOM_f7, 0 },
{ "\033[18^", ATOM_f7, MOD_CTRL },
{ "\033\033[18~", ATOM_f7, MOD_ALT },
{ "\033\033[18^", ATOM_f7, MOD_CTRL | MOD_ALT },
XTERM_MODS_GT("18;", "~", ATOM_f7),
{ "\033[33~", ATOM_f7, MOD_SHIFT },
{ "\033[33^", ATOM_f7, MOD_CTRL | MOD_SHIFT },
{ "\033\033[33~", ATOM_f7, MOD_ALT | MOD_SHIFT },
{ "\033\033[33^", ATOM_f7, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033[18;1~", ATOM_f7, MOD_ALTGR },
{ "\033[19~", ATOM_f8, 0 },
{ "\033[19^", ATOM_f8, MOD_CTRL },
{ "\033\033[19~", ATOM_f8, MOD_ALT },
{ "\033\033[19^", ATOM_f8, MOD_CTRL | MOD_ALT },
XTERM_MODS_GT("19;", "~", ATOM_f8),
{ "\033[34~", ATOM_f8, MOD_SHIFT },
{ "\033[34^", ATOM_f8, MOD_CTRL | MOD_SHIFT },
{ "\033\033[34~", ATOM_f8, MOD_ALT | MOD_SHIFT },
{ "\033\033[34^", ATOM_f8, MOD_CTRL | MOD_ALT | MOD_SHIFT },
{ "\033[19;1~", ATOM_f8, MOD_ALTGR },
{ "\033[20~", ATOM_f9, 0 },
{ "\033[20^", ATOM_f9, MOD_CTRL },
{ "\033\033[20~", ATOM_f9, MOD_ALT },
{ "\033\033[20^", ATOM_f9, MOD_CTRL | MOD_ALT },
XTERM_MODS_GT("20;", "~", ATOM_f9),
{ "\033[20;1~", ATOM_f9, MOD_ALTGR },
{ "\033[21~", ATOM_f10, 0 },
{ "\033[21^", ATOM_f10, MOD_CTRL },
{ "\033\033[21~", ATOM_f10, MOD_ALT },
{ "\033\033[21^", ATOM_f10, MOD_CTRL | MOD_ALT },
XTERM_MODS_GT("21;", "~", ATOM_f10),
{ "\033[21;1~", ATOM_f10, MOD_ALTGR },
{ "\033[23~", ATOM_f11, 0 },
{ "\033[23$", ATOM_f11, MOD_SHIFT },
{ "\033[23^", ATOM_f11, MOD_CTRL },
{ "\033[23@", ATOM_f11, MOD_CTRL | MOD_SHIFT },
{ "\033\033[23~", ATOM_f11, MOD_ALT },
{ "\033\033[23$", ATOM_f11, MOD_ALT | MOD_SHIFT },
{ "\033\033[23^", ATOM_f11, MOD_CTRL | MOD_ALT },
{ "\033\033[23@", ATOM_f11, MOD_CTRL | MOD_ALT | MOD_SHIFT },
XTERM_MODS_GT("23;", "~", ATOM_f11),
{ "\033[23;1~", ATOM_f11, MOD_ALTGR },
{ "\033[24~", ATOM_f12, 0 },
{ "\033[24$", ATOM_f12, MOD_SHIFT },
{ "\033[24^", ATOM_f12, MOD_CTRL },
{ "\033[24@", ATOM_f12, MOD_CTRL | MOD_SHIFT },
{ "\033\033[24~", ATOM_f12, MOD_ALT },
{ "\033\033[24$", ATOM_f12, MOD_ALT | MOD_SHIFT },
{ "\033\033[24^", ATOM_f12, MOD_CTRL | MOD_ALT },
{ "\033\033[24@", ATOM_f12, MOD_CTRL | MOD_ALT | MOD_SHIFT },
XTERM_MODS_GT("24;", "~", ATOM_f12),
{ "\033[24;1~", ATOM_f12, MOD_ALTGR },
//{ "", ATOM_, 0 },
//{ "", ATOM_, 0 },
//{ "", ATOM_, 0 },
{ "\x01", "a", MOD_CTRL | MOD_PRINT },
{ "\033\x01", "a", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x02", "b", MOD_CTRL | MOD_PRINT },
{ "\033\x02", "b", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x03", "c", MOD_CTRL | MOD_PRINT },
{ "\033\x03", "c", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x04", "d", MOD_CTRL | MOD_PRINT },
{ "\033\x04", "d", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x05", "e", MOD_CTRL | MOD_PRINT },
{ "\033\x05", "e", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x06", "f", MOD_CTRL | MOD_PRINT },
{ "\033\x06", "f", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x07", "g", MOD_CTRL | MOD_PRINT },
{ "\033\x07", "g", MOD_CTRL | MOD_ALT | MOD_PRINT },
//{ "\x08", "h", MOD_CTRL | MOD_PRINT },
//+ also ctrl-Backspace
//{ "\033\x08", "h", MOD_CTRL | MOD_ALT | MOD_PRINT },
//+ also ctrl-alt-Backspace (which might not be usable as xorg binds zap to it)
//{ "\x09", "i", MOD_PRINT },
//+ also Tab, Ctrl-Tab
//{ "\033\x09", "i", MOD_ALT | MOD_PRINT },
//+ also Alt-Tab
{ "\x0a", "j", MOD_CTRL | MOD_PRINT },
{ "\033\x0a", "j", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x0b", "k", MOD_CTRL | MOD_PRINT },
{ "\033\x0b", "k", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x0c", "l", MOD_CTRL | MOD_PRINT },
{ "\033\x0c", "l", MOD_CTRL | MOD_ALT | MOD_PRINT },
//{ "\x0d", "m", MOD_CTRL | MOD_PRINT },
//+ also Return, Ctrl-Return
//{ "\033\x0d", "m", MOD_CTRL | MOD_ALT | MOD_PRINT },
//+ also alt-Return, alt-Ctrl-Return
{ "\x0e", "n", MOD_CTRL | MOD_PRINT },
{ "\033\x0e", "n", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x0f", "o", MOD_CTRL | MOD_PRINT },
{ "\033\x0f", "o", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x10", "p", MOD_CTRL | MOD_PRINT },
{ "\033\x10", "p", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x11", "q", MOD_CTRL | MOD_PRINT },
{ "\033\x11", "q", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x12", "r", MOD_CTRL | MOD_PRINT },
{ "\033\x12", "r", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x13", "s", MOD_CTRL | MOD_PRINT },
{ "\033\x13", "s", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x14", "t", MOD_CTRL | MOD_PRINT },
{ "\033\x14", "t", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x15", "u", MOD_CTRL | MOD_PRINT },
{ "\033\x15", "u", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x16", "v", MOD_CTRL | MOD_PRINT },
{ "\033\x16", "v", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x17", "w", MOD_CTRL | MOD_PRINT },
{ "\033\x17", "w", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x18", "x", MOD_CTRL | MOD_PRINT },
{ "\033\x18", "x", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x19", "y", MOD_CTRL | MOD_PRINT },
{ "\033\x19", "y", MOD_CTRL | MOD_ALT | MOD_PRINT },
{ "\x1a", "z", MOD_CTRL | MOD_PRINT },
{ "\033\x1a", "z", MOD_CTRL | MOD_ALT | MOD_PRINT },
//{ "\x1b", "[", MOD_CTRL | MOD_PRINT },
//+ also ESC
//+ also ctrl-3
{ "\x1c", "\\", MOD_CTRL | MOD_PRINT },
{ "\033\x1c", "\\", MOD_CTRL | MOD_ALT | MOD_PRINT },
//+ also ctrl-4
{ "\x1d", "]", MOD_CTRL | MOD_PRINT },
//+ also ctrl-5
{ "\033\x1d", "]", MOD_CTRL | MOD_ALT | MOD_PRINT },
//+ also alt-ctrl-5
{ "\x1e", "~", MOD_CTRL | MOD_PRINT },
//+ also ctrl-6
{ "\033\x1e", "~", MOD_CTRL | MOD_ALT | MOD_PRINT },
//+ also alt-ctrl-6
{ "\x1f", "?", MOD_CTRL | MOD_PRINT },
{ "\033\x1f", "?", MOD_CTRL | MOD_ALT | MOD_PRINT },
//+ also ctrl-7
{ "\x7f", ATOM_backspace, 0 },
{ "\x08", ATOM_backspace, MOD_CTRL },
{ "\033\x08", ATOM_backspace, MOD_CTRL | MOD_ALT },
{ "\033\x7f", ATOM_backspace, MOD_ALT },
XTERM_MODS("\033[27;", ";127~", ATOM_backspace), // modifiy other keys mode
XTERM_MODS("\033[127;", "u", ATOM_backspace), // modifiy other keys mode
XTERM_MODS("\033[27;", ";8~", ATOM_backspace), // modifiy other keys mode
XTERM_MODS("\033[8;", "u", ATOM_backspace), // modifiy other keys mode
{ 0, 0, 0 }
};
void termpaintp_input_selfcheck(void) {
static bool finished;
if (finished) return;
bool ok = true;
for (const key_mapping_entry* entry_a = key_mapping_table; entry_a->sequence != nullptr; entry_a++) {
for (const key_mapping_entry* entry_b = entry_a; entry_b->sequence != nullptr; entry_b++) {
if (entry_a != entry_b && strcmp(entry_a->sequence, entry_b->sequence) == 0) {
printf("Duplicate key mapping: %s == %s\n", entry_a->atom, entry_b->atom);
ok = false;
}
}
}
if (!ok) {
exit(55);
}
finished = true;
}
void termpaintp_input_dump_table(void) {
FILE * f = fopen("input.dump", "w");
if (!f) {
abort();
}
for (const key_mapping_entry* entry_a = key_mapping_table; entry_a->sequence != nullptr; entry_a++) {
fputs(entry_a->sequence, f);
fputs("\n", f);
}
fclose(f);
}
#define MAX_SEQ_LENGTH 1024
enum termpaint_input_state {
tpis_base,
tpis_esc,
tpis_ss3,
tpis_csi,
tpis_cmd_str,
tpis_cmd_str_c1,
tpis_str_terminator_esc,
tpid_utf8_5, tpid_utf8_4, tpid_utf8_3, tpid_utf8_2, tpid_utf8_1,
tpis_mouse_btn, tpis_mouse_col, tpis_mouse_row
};
struct termpaint_input_ {
unsigned char buff[MAX_SEQ_LENGTH];
int used;
enum termpaint_input_state state;
_Bool overflow;
_Bool esc_pending;
int expect_cursor_position_report;
_Bool expect_mouse_char_mode;
_Bool expect_mouse_multibyte_mode;
_Bool expect_apc;
_Bool in_paste;
_Bool handle_paste;
int quirks_len;
key_mapping_entry *quirks;
_Bool extended_unicode;
_Bool (*raw_filter_cb)(void *user_data, const char *data, unsigned length, _Bool overflow);
void *raw_filter_user_data;
void (*event_cb)(void *, termpaint_event *);
void *event_user_data;
};
static void termpaintp_input_reset(termpaint_input *ctx) {
ctx->used = 0;
ctx->overflow = 0;
ctx->state = tpis_base;
}
static bool termpaintp_input_checked_append_digit(int *to_update, int base, int value) {
int tmp;
if (termpaint_smul_overflow(*to_update, base, &tmp)) {
return false;
}
if (termpaint_sadd_overflow(tmp, value, to_update)) {
return false;
}
return true;
}
static bool termpaintp_input_parse_mb_3(const unsigned char *data, size_t length, int *a, int *b, int *c) {
if (length < 3) { // three values -> at least 3 bytes
return false;
}
const size_t len_a = termpaintp_utf8_len(data[0]);
if (len_a >= length // including first byte of b
|| !termpaintp_check_valid_sequence(data, len_a)) {
return false;
}
*a = termpaintp_utf8_decode_from_utf8(data, len_a);
const size_t len_b = termpaintp_utf8_len(data[len_a]);
if (len_a + len_b >= length // including first byte of c
|| !termpaintp_check_valid_sequence(data + len_a, len_b)) {
return false;
}
*b = termpaintp_utf8_decode_from_utf8(data + len_a, len_b);
const size_t len_c = termpaintp_utf8_len(data[len_a + len_b]);
if (len_a + len_b + len_c != length // don't allow trailing garbage
|| !termpaintp_check_valid_sequence(data + len_a + len_b, len_c)) {
return false;
}
*c = termpaintp_utf8_decode_from_utf8(data + len_a + len_b, len_c);
return true;
}
static void termpaintp_input_translate_mouse_flags(termpaint_event* event, int mode) {
// mode = 0 -> release if button is 3 (all modes except 1006)
// mode = 1 -> release from final (mode 1006 with 'm' as final)
// mode = 2 -> press from final (mode 1006 with 'M' as final)
// shuffle the bits from the raw button and flags
event->mouse.button = event->mouse.raw_btn_and_flags & 0x3;
if (event->mouse.raw_btn_and_flags & 0x40) {
event->mouse.button |= 4;
}
if (event->mouse.raw_btn_and_flags & 0x80) {
event->mouse.button |= 8;
}
event->mouse.modifier = 0;
if (event->mouse.raw_btn_and_flags & 0x4) {
event->mouse.modifier |= TERMPAINT_MOD_SHIFT;
}
if (event->mouse.raw_btn_and_flags & 0x8) {
event->mouse.modifier |= TERMPAINT_MOD_ALT;
}
if (event->mouse.raw_btn_and_flags & 0x10) {
event->mouse.modifier |= TERMPAINT_MOD_CTRL;
}
if (event->mouse.raw_btn_and_flags & 0x20) {
event->mouse.action = TERMPAINT_MOUSE_MOVE;
} else if (mode == 0) {
event->mouse.action = event->mouse.button != 3 ? TERMPAINT_MOUSE_PRESS : TERMPAINT_MOUSE_RELEASE;
} else if (mode == 1) {
event->mouse.action = TERMPAINT_MOUSE_RELEASE;
} else {
event->mouse.action = TERMPAINT_MOUSE_PRESS;
}
}
static void termpaintp_input_raw(termpaint_input *ctx, const unsigned char *data, size_t length, _Bool overflow) {
unsigned char dbl_esc_tmp[21];
// First handle double escape for alt-ESC
if (overflow) {
// overflow just reset to base state.
ctx->esc_pending = false;
} else {
if (!ctx->esc_pending) {
if (length == 1 && data[0] == '\033') {
// skip processing this, either next key or resync will trigger real handling
ctx->esc_pending = true;
return;
}
} else {
ctx->esc_pending = false;
bool found = false;
if (length + 1 < sizeof (dbl_esc_tmp)) {
dbl_esc_tmp[0] = '\033';
memcpy(dbl_esc_tmp + 1, data, length);
for (const key_mapping_entry* entry = key_mapping_table; entry->sequence != nullptr; entry++) {
if (strlen(entry->sequence) == length + 1 && memcmp(entry->sequence, dbl_esc_tmp, length + 1) == 0) {
found = true;
}
}
}
if (found) {
// alt-, this is just one event
length += 1;
data = dbl_esc_tmp;
} else {
// something else, two events
if (ctx->raw_filter_cb && ctx->raw_filter_cb(ctx->raw_filter_user_data, (const char *)"\033", 1, false)) {
; // skipped by raw filter
} else if (ctx->event_cb) {
termpaint_event event;
event.type = TERMPAINT_EV_KEY;
event.key.length = strlen(ATOM_escape);
event.key.atom = ATOM_escape;
event.key.modifier = 0;
ctx->event_cb(ctx->event_user_data, &event);
}
}
}
}
if (ctx->raw_filter_cb) {
if (ctx->raw_filter_cb(ctx->raw_filter_user_data, (const char *)data, length, overflow)) {
return;
}
}
if (!ctx->event_cb) {
return;
}
unsigned char buffer[6];
termpaint_event event;
event.type = 0;
if (overflow) {
event.type = TERMPAINT_EV_OVERFLOW;
/*event.length = 0;
event.atom_or_string = 0;
event.modifier = 0;*/
} else if (length == 0) {
// length == 0 should only be possible with overflow. Bailing here removes some conditions later.
return;
} else if (length == 1 && data[0] == 0) {
event.type = TERMPAINT_EV_KEY;
event.key.length = strlen(ATOM_space);
event.key.atom = ATOM_space;
event.key.modifier = MOD_CTRL;
} else if (length == 2 && data[0] == '\033' && data[1] == 0) {
event.type = TERMPAINT_EV_KEY;
event.key.length = strlen(ATOM_space);
event.key.atom = ATOM_space;
event.key.modifier = MOD_CTRL | MOD_ALT;
} else {
const key_mapping_entry* matched_entry = nullptr;
for (int i = 0; i < ctx->quirks_len; i++) {
const key_mapping_entry* entry = &ctx->quirks[i];
if (strlen(entry->sequence) == length && memcmp(entry->sequence, data, length) == 0) {
matched_entry = entry;
break;
}
}
// TODO optimize
if (!matched_entry) {
for (const key_mapping_entry* entry = key_mapping_table; entry->sequence != nullptr; entry++) {
if (strlen(entry->sequence) == length && memcmp(entry->sequence, data, length) == 0) {
matched_entry = entry;
break;
}
}
}
if (matched_entry) {
if (matched_entry->modifiers & MOD_PRINT) {
// special case for ctrl-X which is in the table but a modified printable
event.type = TERMPAINT_EV_CHAR;
event.c.length = strlen(matched_entry->atom);
event.c.string = matched_entry->atom;
event.c.modifier = matched_entry->modifiers & ~MOD_PRINT;
} else {
event.type = TERMPAINT_EV_KEY;
event.key.length = strlen(matched_entry->atom);
event.key.atom = matched_entry->atom;
event.key.modifier = matched_entry->modifiers;
}
}
if (length == 4 && data[0] == '\033' && data[1] == '[' && data[2] == '0' && data[3] == 'n') {
event.type = TERMPAINT_EV_MISC;
event.misc.atom = ATOM_i_resync;
event.misc.length = strlen(ATOM_i_resync);
}
if (!event.type && length >= 2 && data[0] == '\033' && (0xc0 == (0xc0 & data[1]))) {
// tokenizer can only abort on invalid utf-8 sequences, so now recheck and issue a distinct event type
event.type = termpaintp_check_valid_sequence(data+1, length - 1) ? TERMPAINT_EV_CHAR : TERMPAINT_EV_INVALID_UTF8;
if (length - 1 > 4 && !ctx->extended_unicode) {
event.type = TERMPAINT_EV_INVALID_UTF8;
}
event.c.length = length-1;
event.c.string = (const char*)data+1;
event.c.modifier = MOD_ALT;
}
if (!event.type && length == 2 && data[0] == '\033' && data[1] > 32 && data[1] < 127) {
event.type = TERMPAINT_EV_CHAR;
event.c.length = length-1;
event.c.string = (const char*)data+1;
event.c.modifier = MOD_ALT;
}
if (!event.type && (0xc0 == (0xc0 & data[0]))) {
// tokenizer can only abort on invalid utf-8 sequences, so now recheck and issue a distinct event type
event.type = termpaintp_check_valid_sequence(data, length) ? TERMPAINT_EV_CHAR : TERMPAINT_EV_INVALID_UTF8;
if (length > 4 && !ctx->extended_unicode) {
event.type = TERMPAINT_EV_INVALID_UTF8;
}
event.c.length = length;
event.c.string = (const char*)data;
event.c.modifier = 0;
}
if (!event.type && length == 1 && data[0] > 32 && data[0] < 127) {
event.type = TERMPAINT_EV_CHAR;
event.c.length = length;
event.c.string = (const char*)data;
event.c.modifier = 0;
}
if (length > 2 && data[0] == '\033' && data[1] == '[') {
int params_start = 2;
int params_len = length - 3;
// scan for shape
char prefix_modifier = 0;
char postfix_modifier = 0;
char final = 0;
const int default_arg = -1;
int args[10] = { 0 };
bool has_sub_args = false;
const int max_args = sizeof(args) / sizeof(*args);
int arg_count = 0;
enum state_t {
S_initial, S_main_param, S_sub_param, S_ignore
} state = S_initial;
bool ok = true;
for (size_t j = 2; j < length; j++) {
if ('0' <= data[j] && data[j] <= '9') {
if (state == S_initial) {
if (arg_count >= max_args) {
state = S_ignore;
} else {
state = S_main_param;
++arg_count;
}
}
if (state == S_main_param) {
if (!termpaintp_input_checked_append_digit(&args[arg_count - 1], 10, data[j] - '0')) {
// parameter out of range
state = S_ignore;
ok = false;
}
}
} else if (':' == data[j]) {
has_sub_args = true;
if (state == S_initial) {
if (arg_count >= max_args) {
state = S_ignore;
} else {
++arg_count;
args[arg_count - 1] = default_arg;
state = S_sub_param;
}
} else if (state == S_main_param) {
state = S_sub_param;
}
} else if (data[j] == ';') {
if (state == S_initial) {
if (arg_count >= max_args) {
state = S_ignore;
} else {
++arg_count;
args[arg_count - 1] = default_arg;
state = S_initial;
}
} else if (state == S_main_param) {
state = S_initial;
} else if (state == S_sub_param) {
state = S_initial;
}
} else if ('<' <= data[j] && data[j] <= '?') {
// prefix modifier
if (j == 2) {
// at the very beginning
prefix_modifier = data[j];
++params_start;
--params_len;
} else {
// at an unexpected place
ok = false;
break;
}
} else if (' ' <= data[j] && data[j] <= '/') {
// postfix modifier
if (j == length - 2) {
// just before final character
postfix_modifier = data[j];
--params_len;
} else {
// at an unexpected place
ok = false;
break;
}
} else if ('@' <= data[j] && data[j] <= 127) {
// final character
if (j == length - 1) {
// and actually in the final byte
final = data[j];
} else {
// at an unexpected place
ok = false;
break;
}
} else {
ok = false;
break;
}
}
if (state == S_initial && arg_count > 0 && arg_count < max_args) {
++arg_count;
args[arg_count - 1] = default_arg;
}
#define SEQ(f, pre, post) (((pre) << 16) | ((post) << 8) | (f))
int32_t sequence_id = ok ? SEQ(final, prefix_modifier, postfix_modifier) : 0;
// the CSI sequence is just a prefix in legacy mouse modes.
if (!event.type && length >= 6 && data[2] == 'M') {
if (length == 6) {
if (data[3] >= 32 && data[4] > 32 && data[5] > 32) {
// only translate non overflow mouse reports (some terminals overflow into the C0 range,
// ignore those too)
event.type = TERMPAINT_EV_MOUSE;
event.mouse.raw_btn_and_flags = data[3] - ' ';
event.mouse.x = data[4] - '!';
event.mouse.y = data[5] - '!';
termpaintp_input_translate_mouse_flags(&event, 0);
}
} else {
int x, y, btn;
if (termpaintp_input_parse_mb_3(data + 3, length - 3, &btn, &x, &y)) {
if (btn >= 32 && x > 32 && y > 32) {
// here no overflow should be possible. But the substractions would yield negative values
// otherwise
event.mouse.raw_btn_and_flags = btn - ' ';
event.mouse.x = x - '!';
event.mouse.y = y - '!';
termpaintp_input_translate_mouse_flags(&event, 0);
event.type = TERMPAINT_EV_MOUSE;
}
}
}
}
if (!event.type && sequence_id == SEQ('M', 0, 0) && length > 7) {
// urxvt mouse mode 1015
if (arg_count == 3 && !has_sub_args) {
int btn = args[0];
int x = args[1];
int y = args[2];
if (btn >= ' ' && x > 0 && y > 0) {
event.type = TERMPAINT_EV_MOUSE;
event.mouse.raw_btn_and_flags = btn - ' ';
event.mouse.x = x - 1;
event.mouse.y = y - 1;
termpaintp_input_translate_mouse_flags(&event, 0);
}
}
}
if (!event.type && length > 8 && (sequence_id == SEQ('M', '<', 0) || sequence_id == SEQ('m', '<', 0))) {
// mouse mode 1006
if (arg_count == 3 && !has_sub_args) {
int btn = (args[0] != default_arg ? args[0] : 0);
int x = args[1];
int y = args[2];
if (x > 0 && y > 0) {
event.type = TERMPAINT_EV_MOUSE;
event.mouse.raw_btn_and_flags = btn;
event.mouse.x = x - 1;
event.mouse.y = y - 1;
termpaintp_input_translate_mouse_flags(&event, data[length - 1] == 'm' ? 1 : 2);
}
}
}
// the nice key modifier extensions:
// \033[27;;~
// \033[;u
if (!event.type
&& ((sequence_id == SEQ('~', 0, 0) && arg_count >= 3 && args[0] == 27)
|| (sequence_id == SEQ('u', 0, 0) && arg_count >= 2 && !has_sub_args))) {
// see further down for other CSI ~ sequences
int mod, codepoint;
if (sequence_id == SEQ('u', 0, 0)) {
codepoint = args[0];
mod = args[1];
} else {
// ~ variant
mod = args[1];
codepoint = args[2];
}
if (mod == 0) {
// This does not happen in tested terminals but
// https://www.leonerd.org.uk/hacks/fixterms/
// implies we should just default to 1
mod = 1;
}
if (codepoint >= 32 && codepoint <= 0x7FFFFFFF
&& !(codepoint >= 0x80 && codepoint <= 0xa0)
&& codepoint != 0x7f) {
event.type = TERMPAINT_EV_CHAR;
event.c.length = termpaintp_encode_to_utf8(codepoint, buffer);
event.c.string = (char*)buffer;
event.c.modifier = 0;
mod = mod - 1;
if (mod & 1) {
event.c.modifier |= MOD_SHIFT;
}
if (mod & 2) {
event.c.modifier |= MOD_ALT;
}
if (mod & 4) {
event.c.modifier |= MOD_CTRL;
}
}
}
if ((!event.type || ctx->expect_cursor_position_report > 0)
&& length > 5 && (sequence_id == SEQ('R', 0, 0) || sequence_id == SEQ('R', '?', 0))) {
if (arg_count >= 2 && !has_sub_args) {
int y = args[0];
int x = args[1];
if (x > 0 && y > 0) {
event.type = TERMPAINT_EV_CURSOR_POSITION;
event.cursor_position.x = x - 1;
event.cursor_position.y = y - 1;
if (prefix_modifier == 0) {
ctx->expect_cursor_position_report -= 1;
}
event.cursor_position.safe = prefix_modifier == '?';
}
}
}
if (!event.type && params_len == 0
&& (sequence_id == SEQ('O', 0, 0) || sequence_id == SEQ('I', 0, 0))) {
event.type = TERMPAINT_EV_MISC;
event.misc.atom = sequence_id == SEQ('I', 0, 0) ? termpaint_input_focus_in()
: termpaint_input_focus_out();
event.misc.length = strlen(event.misc.atom);
}
if (!event.type && sequence_id == SEQ('~', 0, 0)) { // see above for CSI 27;;~
if (arg_count >= 1 && !has_sub_args) {
int num = args[0];
if (num == 200) {
if (ctx->handle_paste) {
ctx->in_paste = true;
termpaint_event event2;
event2.type = TERMPAINT_EV_PASTE;
event2.paste.string = "";
event2.paste.length = 0;
event2.paste.initial = true;
event2.paste.final = false;
ctx->event_cb(ctx->event_user_data, &event2);
} else {
event.type = TERMPAINT_EV_MISC;
event.misc.atom = termpaint_input_paste_begin();
event.misc.length = strlen(event.misc.atom);
}
} else if (num == 201) {
if (ctx->handle_paste) {
ctx->in_paste = false;
event.type = TERMPAINT_EV_PASTE;
event.paste.string = "";
event.paste.length = 0;
event.paste.initial = false;
event.paste.final = true;
} else {
event.type = TERMPAINT_EV_MISC;
event.misc.atom = termpaint_input_paste_end();
event.misc.length = strlen(event.misc.atom);
}
}
}
}
if (!event.type) {
if (length > 5 &&
(sequence_id == SEQ('y', 0, '$') || sequence_id == SEQ('y', '?', '$'))) {
if (arg_count >= 2 && !has_sub_args) {
int mode = (args[0] != default_arg ? args[0] : 0);
int status = (args[1] != default_arg ? args[1] : 0);
event.type = TERMPAINT_EV_MODE_REPORT;
event.mode.number = mode;
event.mode.kind = (prefix_modifier == '?') ? 1 : 0;
event.mode.status = status;
}
}
if (sequence_id == SEQ('c', '>', 0)) {
event.type = TERMPAINT_EV_RAW_SEC_DEV_ATTRIB;
event.raw.string = (const char*)data;
event.raw.length = length;
}
if (sequence_id == SEQ('c', '?', 0)) {
event.type = TERMPAINT_EV_RAW_PRI_DEV_ATTRIB;
event.raw.string = (const char*)data;
event.raw.length = length;
}
// prefix_modifier == '?' is possible here, VTE < 0.54 answers this to CSI 1x
if (sequence_id == SEQ('x', 0, 0) || sequence_id == SEQ('x', '?', 0)) {
event.type = TERMPAINT_EV_RAW_DECREQTPARM;
event.raw.string = (const char*)data;
event.raw.length = length;
}
}
#undef SEQ
}
if (!event.type && length > 5 && data[0] == '\033' && data[1] == ']' &&
((data[length-1] == '\\' && data[length-2] == '\033') || (data[length-1] == '\x07') || (data[length-1] == 0x9c))) {
// OSC sequences
size_t st_offset;
if (data[length-1] == '\\') {
st_offset = length - 2;
} else {
st_offset = length - 1;
}
int num; // -1 -> not a numerical OSC
size_t num_end = 0;
if ('0' <= data[2] && data[2] <= '9') {
num = 0;
for (size_t i = 2; i < st_offset; i++) {
if (data[i] == ';') {
num_end = i;
// finished
break;
} else if ('0' <= data[i] && data[i] <= '9') {
if (!termpaintp_input_checked_append_digit(&num, 10, data[i] - '0')) {
num = -1;
break;
}
} else {
// bail
num = -1;
break;
}
}
} else {
num = -1;
}
if (num_end && num == 4) {
event.palette_color_report.color_index = 0;
// the normal report has the form OSC 4 ; color_index ; color_desc ST
// but at least urxvt does send an different form of OSC 4 ; color_desc ST
// (set color_index == -1 in the event in that case)
bool color_index_ok = true;
size_t end_idx1 = num_end + 1;
while (end_idx1 < st_offset && data[end_idx1] != ';') {
if ('0' <= data[end_idx1] && data[end_idx1] <= '9') {
if (!termpaintp_input_checked_append_digit(&event.palette_color_report.color_index,
10, data[end_idx1] - '0')) {
color_index_ok = false;
}
} else {
color_index_ok = false;
}
end_idx1++;
}
if (end_idx1 + 1 < st_offset) {
size_t end_idx2 = end_idx1 + 1;
while (end_idx2 < st_offset && data[end_idx2] != ';') {
end_idx2++;
}
if (color_index_ok) {
event.type = TERMPAINT_EV_PALETTE_COLOR_REPORT;
event.palette_color_report.color_desc = (const char*)data + end_idx1 + 1;
event.palette_color_report.length = end_idx2 - end_idx1 - 1;
}
} else {
event.palette_color_report.color_index = -1;
event.type = TERMPAINT_EV_PALETTE_COLOR_REPORT;
event.palette_color_report.color_desc = (const char*)data + num_end + 1;
event.palette_color_report.length = end_idx1 - num_end - 1;
}
}
if (num_end && ((num >= 10 && num <= 14) || num == 17 || num == 19 || (num >= 705 && num <= 708))) {
event.type = TERMPAINT_EV_COLOR_SLOT_REPORT;
event.color_slot_report.slot = num;
event.color_slot_report.color = (const char*)data + num_end + 1;
size_t end_idx = num_end + 1;
while (end_idx < st_offset && data[end_idx] != ';') {
end_idx++;
}
event.color_slot_report.length = end_idx - num_end - 1;
}
}
if (!event.type && length > 5 && data[0] == '\033' && data[1] == 'P' && data[length-1] == '\\' && data[length-2] == '\033') {
// DCS sequences
if (data[2] == '!' && data[3] == '|') {
event.type = TERMPAINT_EV_RAW_3RD_DEV_ATTRIB;
event.raw.string = (const char*)data + 4;
event.raw.length = length - 6;
}
if (data[2] == '>' && data[3] == '|') {
event.type = TERMPAINT_EV_RAW_TERM_NAME;
event.raw.string = (const char*)data + 4;
event.raw.length = length - 6;
}
if ((data[2] == '1' || data[2] == '0') && data[3] == '+' && data[4] == 'r') {
event.type = TERMPAINT_EV_RAW_TERMINFO_QUERY_REPLY;
event.raw.string = (const char*)data + 2;
event.raw.length = length - 4;
}
}
if (!event.type && length > 3 && data[0] == 0x90 && data[length-1] == 0x9c) {
// DCS sequences
if (data[1] == '!' && data[2] == '|') {
event.type = TERMPAINT_EV_RAW_3RD_DEV_ATTRIB;
event.raw.string = (const char*)data + 3;
event.raw.length = length - 4;
}
}
}
if (!ctx->in_paste) {
ctx->event_cb(ctx->event_user_data, &event);
} else {
// while in paste state ignore anything that is not a plain character.
// in a paste there shouldn't be any escape sequences, but don't depend on
// all terminals applying strict filtering.
if (event.type == TERMPAINT_EV_CHAR && event.c.modifier == 0) {
termpaint_event event2;
event2.type = TERMPAINT_EV_PASTE;
event2.paste.string = event.c.string;
event2.paste.length = event.c.length;
event2.paste.initial = false;
event2.paste.final = false;
ctx->event_cb(ctx->event_user_data, &event2);
}
// some terminals send line breaks as \x0a
if (event.type == TERMPAINT_EV_CHAR && event.c.modifier == TERMPAINT_MOD_CTRL
&& event.c.length == 1 && event.c.string[0] == 'j') {
termpaint_event event2;
event2.type = TERMPAINT_EV_PASTE;
event2.paste.string = "\n";
event2.paste.length = 1;
event2.paste.initial = false;
event2.paste.final = false;
ctx->event_cb(ctx->event_user_data, &event2);
}
// But some plain strings are handled as keys, so process those as well
if (event.type == TERMPAINT_EV_KEY && event.key.modifier == 0) {
termpaint_event event2;
event2.type = TERMPAINT_EV_PASTE;
event2.paste.initial = false;
event2.paste.final = false;
if (event.key.atom == termpaint_input_space()) {
event2.paste.string = " ";
event2.paste.length = 1;
ctx->event_cb(ctx->event_user_data, &event2);
}
if (event.key.atom == termpaint_input_tab()) {
event2.paste.string = "\t";
event2.paste.length = 1;
ctx->event_cb(ctx->event_user_data, &event2);
}
if (event.key.atom == termpaint_input_enter()) {
event2.paste.string = "\r";
event2.paste.length = 1;
ctx->event_cb(ctx->event_user_data, &event2);
}
}
}
}
termpaint_input *termpaint_input_new_or_nullptr(void) {
termpaintp_input_selfcheck();
termpaint_input *ctx = calloc(1, sizeof(termpaint_input));
if (!ctx) {
return nullptr;
}
termpaintp_input_reset(ctx);
ctx->esc_pending = false;
ctx->raw_filter_cb = nullptr;
ctx->event_cb = nullptr;
ctx->expect_cursor_position_report = 0;
ctx->handle_paste = true;
return ctx;
}
termpaint_input *termpaint_input_new(void) {
termpaint_input *ret = termpaint_input_new_or_nullptr();
if (!ret) {
abort();
}
return ret;
}
void termpaint_input_free(termpaint_input *ctx) {
if (!ctx) {
return;
}
for (int i = 0; i < ctx->quirks_len; i++) {
key_mapping_entry* entry = &ctx->quirks[i];
free((void*)entry->sequence); // cast away const, quirks is always dynamically allocated.
if (entry->modifiers & MOD_PRINT) {
free((void*)entry->atom); // cast away const, quirks is always dynamically allocated.
}
}
free(ctx->quirks);
free(ctx);
}
void termpaint_input_set_raw_filter_cb(termpaint_input *ctx, _Bool (*cb)(void *user_data, const char *data, unsigned length, _Bool overflow), void *user_data) {
ctx->raw_filter_cb = cb;
ctx->raw_filter_user_data = user_data;
}
void termpaint_input_set_event_cb(termpaint_input *ctx, void (*cb)(void *, termpaint_event *), void *user_data) {
ctx->event_cb = cb;
ctx->event_user_data = user_data;
}
static bool termpaintp_input_legacy_mouse_bytes_finished(termpaint_input *ctx) {
const unsigned char cur_ch = ctx->buff[ctx->used - 1];
if (0xc0 == (0xc0 & cur_ch)) {
// start of multi code unit sequence.
if (ctx->used >= 2 && (0xc0 == (0xc0 & ctx->buff[ctx->used - 2]))) {
// multiple start characters without continuation -> bogus
return true;
} else {
return false;
}
} else if (0x80 == (0x80 & cur_ch)) {
// continuation
for (int j = ctx->used - 2; j > 0; j--) {
if (j <= ctx->used - 5 || !(0x80 & ctx->buff[j])) {
return true;
}
if ((ctx->buff[j] & 0xc0) == 0xc0) {
int len = termpaintp_utf8_len(ctx->buff[j]);
if (len <= ctx->used - j) {
return true;
} else {
return false;
}
}
}
return true;
} else {
return true;
}
}
void termpaint_input_add_data(termpaint_input *ctx, const char *data_s, unsigned length) {
const unsigned char *data = (const unsigned char*)data_s;
for (unsigned i = 0; i < length; i++) {
// Protect against overlong sequences
if (ctx->used == MAX_SEQ_LENGTH) {
// go to error recovery
ctx->buff[0] = 0;
ctx->used = 0;
ctx->overflow = 1;
}
const unsigned char cur_ch = data[i];
ctx->buff[ctx->used] = cur_ch;
++ctx->used;
// Don't use data or i after here!
bool finished = false;
bool retrigger = false;
bool retrigger2 = false; // used in tpis_cmd_str to reprocess "\033[" (last 2 chars)
switch (ctx->state) {
case tpis_base:
// expected: ctx->used == 0
// detect possible utf-8 multi char start bytes
if (0xfc == (0xfe & cur_ch)) {
ctx->state = tpid_utf8_5;
} else if (0xf8 == (0xfc & cur_ch)) {
ctx->state = tpid_utf8_4;
} else if (0xf0 == (0xf8 & cur_ch)) {
ctx->state = tpid_utf8_3;
} else if (0xe0 == (0xf0 & cur_ch)) {
ctx->state = tpid_utf8_2;
} else if (0xc0 == (0xe0 & cur_ch)) {
ctx->state = tpid_utf8_1;
// escape sequence starts
} else if (cur_ch == '\033') {
ctx->state = tpis_esc;
} else if (cur_ch == 0x8f) { // SS3
ctx->state = tpis_ss3;
} else if (cur_ch == 0x90) { // DCS
ctx->state = tpis_cmd_str_c1;
} else if (cur_ch == 0x9b) { // CSI
ctx->state = tpis_csi;
} else if (cur_ch == 0x9d) { // OSC
ctx->state = tpis_cmd_str_c1;
} else {
finished = true;
}
break;
case tpis_esc:
if (cur_ch == 'O') {
ctx->state = tpis_ss3;
} else if (cur_ch == 'P') {
ctx->state = tpis_cmd_str;
} else if (cur_ch == '[') {
ctx->state = tpis_csi;
} else if (cur_ch == ']') {
ctx->state = tpis_cmd_str;
} else if (ctx->expect_apc && cur_ch == '_') { // APC
ctx->state = tpis_cmd_str;
} else if (0xfc == (0xfe & cur_ch)) { // meta -> ESC can produce utf-8 sequences preceeded by an ESC
ctx->state = tpid_utf8_5;
} else if (0xf8 == (0xfc & cur_ch)) {
ctx->state = tpid_utf8_4;
} else if (0xf0 == (0xf8 & cur_ch)) {
ctx->state = tpid_utf8_3;
} else if (0xe0 == (0xf0 & cur_ch)) {
ctx->state = tpid_utf8_2;
} else if (0xc0 == (0xe0 & cur_ch)) {
ctx->state = tpid_utf8_1;
} else if (cur_ch == '\033') {
retrigger = true;
} else {
finished = true;
}
break;
case tpis_ss3:
// this ss3 stuff is totally undocumented. But various codes
// are seen in the wild that extend these codes by embedding
// parameters
if ((cur_ch >= '0' && cur_ch <= '9') || cur_ch == ';') {
;
} else if (cur_ch == '\033') {
retrigger = true;
} else {
finished = true;
}
break;
case tpis_csi:
if (ctx->used == 3 && cur_ch == 'M' && ctx->buff[ctx->used - 2] == '[' && (ctx->expect_mouse_char_mode || ctx->expect_mouse_multibyte_mode)) {
ctx->state = tpis_mouse_btn;
} else if (cur_ch >= '@' && cur_ch <= '~' && (cur_ch != '[' || ctx->used != 3 /* linux vt*/)) {
finished = true;
} else if (cur_ch == '\033') {
retrigger = true;
}
break;
case tpis_cmd_str:
if (cur_ch == '\033') {
ctx->state = tpis_str_terminator_esc;
} else if (cur_ch == 0x9c || cur_ch == 0x07) {
finished = true;
}
break;
case tpis_cmd_str_c1:
if (cur_ch == 0x9c) {
finished = true;
}
break;
case tpis_str_terminator_esc:
// we expect a '\\' here. But every other char also aborts parsing
if (cur_ch == '[') {
// as a workaround for retriggering:
retrigger2 = true;
} else {
finished = true;
}
break;
case tpid_utf8_5:
if ((cur_ch & 0xc0) != 0x80) {
// encoding error, abort sequence
retrigger = true;
} else {
ctx->state = tpid_utf8_4;
}
break;
case tpid_utf8_4:
if ((cur_ch & 0xc0) != 0x80) {
// encoding error, abort sequence
retrigger = true;
} else {
ctx->state = tpid_utf8_3;
}
break;
case tpid_utf8_3:
if ((cur_ch & 0xc0) != 0x80) {
// encoding error, abort sequence
retrigger = true;
} else {
ctx->state = tpid_utf8_2;
}
break;
case tpid_utf8_2:
if ((cur_ch & 0xc0) != 0x80) {
// encoding error, abort sequence
retrigger = true;
} else {
ctx->state = tpid_utf8_1;
}
break;
case tpid_utf8_1:
if ((cur_ch & 0xc0) != 0x80) {
// encoding error, abort sequence
retrigger = true;
} else {
finished = true;
}
break;
case tpis_mouse_btn:
if (!ctx->expect_mouse_multibyte_mode) {
ctx->state = tpis_mouse_col;
} else {
if (termpaintp_input_legacy_mouse_bytes_finished(ctx)) {
ctx->state = tpis_mouse_col;
}
}
break;
case tpis_mouse_col:
if (!ctx->expect_mouse_multibyte_mode) {
ctx->state = tpis_mouse_row;
} else {
if (termpaintp_input_legacy_mouse_bytes_finished(ctx)) {
ctx->state = tpis_mouse_row;
}
}
break;
case tpis_mouse_row:
if (!ctx->expect_mouse_multibyte_mode) {
finished = true;
} else {
if (termpaintp_input_legacy_mouse_bytes_finished(ctx)) {
finished = true;
}
}
break;
}
if (finished) {
termpaintp_input_raw(ctx, ctx->buff, ctx->used, ctx->overflow);
termpaintp_input_reset(ctx);
} else if (retrigger2) {
// current and previous char is not part of sequence
if (ctx->used > 2) {
termpaintp_input_raw(ctx, ctx->buff, ctx->used - 2, ctx->overflow);
} else {
termpaintp_input_raw(ctx, ctx->buff, 0, ctx->overflow);
}
termpaintp_input_reset(ctx);
ctx->buff[ctx->used] = '\033';
++ctx->used;
ctx->buff[ctx->used] = '[';
++ctx->used;
ctx->state = tpis_csi;
} else if (retrigger) {
// current char is not part of sequence
termpaintp_input_raw(ctx, ctx->buff, ctx->used - 1, ctx->overflow);
termpaintp_input_reset(ctx);
--i; // process this char again
}
}
}
const char *termpaint_input_peek_buffer(const termpaint_input *ctx) {
return (const char*)ctx->buff;
}
int termpaint_input_peek_buffer_length(const termpaint_input *ctx) {
return ctx->used;
}
void termpaint_input_expect_cursor_position_report(termpaint_input *ctx) {
ctx->expect_cursor_position_report += 1;
}
void termpaint_input_expect_legacy_mouse_reports(termpaint_input *ctx, int s) {
if (s == TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE) {
ctx->expect_mouse_char_mode = true;
ctx->expect_mouse_multibyte_mode = false;
} else if (s == TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE_MODE_1005) {
ctx->expect_mouse_char_mode = false;
ctx->expect_mouse_multibyte_mode = true;
} else {
ctx->expect_mouse_char_mode = false;
ctx->expect_mouse_multibyte_mode = false;
}
}
void termpaint_input_expect_apc_sequences(termpaint_input *ctx, bool enable) {
ctx->expect_apc = enable;
}
static void termpaintp_input_prepend_quirk(termpaint_input *ctx, const key_mapping_entry *e) {
// takes ownership of e.sequence;
key_mapping_entry* new_quirks = calloc(ctx->quirks_len + 1, sizeof(key_mapping_entry));
if (!new_quirks) {
abort();
}
new_quirks[0] = *e;
if (ctx->quirks_len) {
memcpy(new_quirks + 1, ctx->quirks, ctx->quirks_len * sizeof(*ctx->quirks));
}
free(ctx->quirks);
ctx->quirks = new_quirks;
ctx->quirks_len += 1;
}
void termpaint_input_activate_quirk(termpaint_input *ctx, int quirk) {
if (quirk == TERMPAINT_INPUT_QUIRK_BACKSPACE_X08_AND_X7F_SWAPPED) {
{
key_mapping_entry e;
e.atom = termpaint_input_backspace();
e.sequence = strdup("\x08");
if (!e.sequence) {
abort();
}
e.modifiers = 0;
termpaintp_input_prepend_quirk(ctx, &e);
}
{
key_mapping_entry e;
e.atom = termpaint_input_backspace();
e.sequence = strdup("\x7f");
if (!e.sequence) {
abort();
}
e.modifiers = TERMPAINT_MOD_CTRL;
termpaintp_input_prepend_quirk(ctx, &e);
}
} else if (quirk == TERMPAINT_INPUT_QUIRK_C1_FOR_CTRL_SHIFT) {
{
key_mapping_entry e;
e.atom = termpaint_input_space();
e.sequence = strdup("\xc2\x80");
if (!e.sequence) {
abort();
}
e.modifiers = TERMPAINT_MOD_CTRL | TERMPAINT_MOD_SHIFT;
termpaintp_input_prepend_quirk(ctx, &e);
}
for (int i = 0; i < 26; i++) {
key_mapping_entry e;
unsigned char *atom = malloc(2);
if (!atom) {
abort();
}
unsigned char *sequence = malloc(3);
if (!sequence) {
abort();
}
atom[0] = 'A' + i;
atom[1] = 0;
termpaintp_encode_to_utf8(0x81 + i, sequence);
sequence[2] = 0;
e.atom = (char*)atom;
e.sequence = (char*)sequence;
e.modifiers = TERMPAINT_MOD_CTRL | TERMPAINT_MOD_SHIFT | MOD_PRINT;
termpaintp_input_prepend_quirk(ctx, &e);
}
}
}
void termpaint_input_handle_paste(termpaint_input *ctx, bool enable) {
ctx->handle_paste = enable;
if (!enable) {
// TODO emit paste end event here too?
ctx->in_paste = false;
}
}
termpaint-0.3.1/termpaint_input.h 0000664 0000000 0000000 00000003726 14773035472 0017135 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_INPUT_INCLUDED
#define TERMPAINT_TERMPAINT_INPUT_INCLUDED
#include
#ifdef __cplusplus
#ifndef _Bool
#define _Bool bool
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
struct termpaint_input_;
typedef struct termpaint_input_ termpaint_input;
// Usually termpaint_terminal's input integration should be used instead of raw termpaint_input
_tERMPAINT_PUBLIC termpaint_input *termpaint_input_new(void);
_tERMPAINT_PUBLIC termpaint_input *termpaint_input_new_or_nullptr(void);
_tERMPAINT_PUBLIC void termpaint_input_free(termpaint_input *ctx);
_tERMPAINT_PUBLIC void termpaint_input_set_raw_filter_cb(termpaint_input *ctx, _Bool (*cb)(void *user_data, const char *data, unsigned length, _Bool overflow), void *user_data);
_tERMPAINT_PUBLIC void termpaint_input_set_event_cb(termpaint_input *ctx, void (*cb)(void *user_data, termpaint_event* event), void *user_data);
_tERMPAINT_PUBLIC void termpaint_input_add_data(termpaint_input *ctx, const char *data, unsigned length);
_tERMPAINT_PUBLIC void termpaint_input_expect_cursor_position_report(termpaint_input *ctx);
#define TERMPAINT_INPUT_EXPECT_NO_LEGACY_MOUSE 0
#define TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE 1
#define TERMPAINT_INPUT_EXPECT_LEGACY_MOUSE_MODE_1005 2
_tERMPAINT_PUBLIC void termpaint_input_expect_legacy_mouse_reports(termpaint_input *ctx, int s);
_tERMPAINT_PUBLIC void termpaint_input_handle_paste(termpaint_input *ctx, _Bool enable);
_tERMPAINT_PUBLIC void termpaint_input_expect_apc_sequences(termpaint_input *ctx, _Bool enable);
_tERMPAINT_PUBLIC const char* termpaint_input_peek_buffer(const termpaint_input *ctx);
_tERMPAINT_PUBLIC int termpaint_input_peek_buffer_length(const termpaint_input *ctx);
#define TERMPAINT_INPUT_QUIRK_BACKSPACE_X08_AND_X7F_SWAPPED 1
#define TERMPAINT_INPUT_QUIRK_C1_FOR_CTRL_SHIFT 2
_tERMPAINT_PUBLIC void termpaint_input_activate_quirk(termpaint_input *ctx, int quirk);
#ifdef __cplusplus
}
#endif
#endif
termpaint-0.3.1/termpaint_utf8.h 0000664 0000000 0000000 00000015227 14773035472 0016663 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_UTF8_INCLUDED
#define TERMPAINT_TERMPAINT_UTF8_INCLUDED
// internal header, not api or abi stable
/*
x = any bit value
y = at least one needs to be set (to detect overlong encodings which are invalid)
0x00000000 - 0x0000007F:
0xxxxxxx (7bit)
0x00000080 - 0x000007FF:
110yyyyx 10xxxxxx (11bit)
0x00000800 - 0x0000D7FF:
0x0000E000 - 0x0000FFFD:
1110yyyy 10yxxxxx 10xxxxxx (16 bit)
0x00010000 - 0x001FFFFF:
11110yyy 10yyxxxx 10xxxxxx 10xxxxxx (21bit)
0x00200000 - 0x03FFFFFF:
111110yy 10yyyxxx 10xxxxxx 10xxxxxx 10xxxxxx (26bit)
0x04000000 - 0x7FFFFFFF:
1111110y 10yyyyxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx (31bit)
*/
static inline int termpaintp_utf8_len(unsigned char first_byte) {
int size;
if (0xfc == (0xfe & first_byte)) {
size = 6;
} else if (0xf8 == (0xfc & first_byte)) {
size = 5;
} else if (0xf0 == (0xf8 & first_byte)) {
size = 4;
} else if (0xe0 == (0xf0 & first_byte)) {
size = 3;
} else if (0xc0 == (0xe0 & first_byte)) {
size = 2;
} else {
size = 1;
}
return size;
}
// Decodes a utf8 encoded unicode codepoint.
// input MUST point to at least length readable bytes.
// length MUST be the return of termpaintp_utf8_len(*input)
static inline int termpaintp_utf8_decode_from_utf8(const unsigned char *input, int length) {
if (length == 1) {
return *input;
} else if (length == 2) {
return ((input[0] & 0x1f) << 6)
| (input[1] & 0x3f);
} else if (length == 3) {
return ((input[0] & 0x0f) << (6*2))
| ((input[1] & 0x3f) << 6)
| (input[2] & 0x3f);
} else if (length == 4) {
return ((input[0] & 0x07) << (6*3))
| ((input[1] & 0x3f) << (6*2))
| ((input[2] & 0x3f) << 6)
| (input[3] & 0x3f);
} else if (length == 5) {
return ((input[0] & 0x03) << (6*3))
| ((input[1] & 0x3f) << (6*3))
| ((input[2] & 0x3f) << (6*2))
| ((input[3] & 0x3f) << 6)
| (input[4] & 0x3f);
} else if (length == 6) {
return ((input[0] & 0x01) << (6*5))
| ((input[1] & 0x3f) << (6*4))
| ((input[2] & 0x3f) << (6*3))
| ((input[3] & 0x3f) << (6*2))
| ((input[4] & 0x3f) << 6)
| (input[5] & 0x3f);
} else {
return 0;
}
}
static inline _Bool termpaintp_check_valid_sequence(const unsigned char *input, unsigned length) {
#define CHECK_CONTINUATION_BYTE(index) if ((input[index] & 0xc0) != 0x80) return false;
if (length == 0) {
return 0;
}
if ((*input >= 0x80 && *input <= 0xc0) || *input == 0xfe || *input == 0xff) {
return 0;
}
unsigned len = termpaintp_utf8_len(*input);
if (len != length) {
return 0;
}
if (len == 1) {
return 1;
} else if (len == 2) {
CHECK_CONTINUATION_BYTE(1)
return input[0] & 0x1e;
} else if (len == 3) {
CHECK_CONTINUATION_BYTE(1)
CHECK_CONTINUATION_BYTE(2)
//unsigned codepoint = ((input[0] & 0x0f) << 12) | ((input[1] & 0x7f) << 6) | (input[2] & 0x7f);
//return (codepoint >= 0x800 && codepoint < 0xd800) || codepoint >= 0xe000;
// based on table 3-7 in unicode standard (9.0)
if (input[0] == 0xe0) {
// all variable bits in input[0] are zero
// most significant variable bit in input[0] must be set if this is not an overlong sequence
return input[1] >= 0xa0;
} else if (input[0] == 0xed) {
// decoded value begins with 1101
// if code continues with 1xxxxx (thus 1101 1xxxxx ...) it is surrogate
// thus not a valid unicode scalar value
return input[1] < 0xa0;
} else {
return 1;
}
} else if (len == 4) {
CHECK_CONTINUATION_BYTE(1)
CHECK_CONTINUATION_BYTE(2)
CHECK_CONTINUATION_BYTE(3)
return (input[0] & 0x7) + (input[1] & 0x30);
} else if (len == 5) {
CHECK_CONTINUATION_BYTE(1)
CHECK_CONTINUATION_BYTE(2)
CHECK_CONTINUATION_BYTE(3)
CHECK_CONTINUATION_BYTE(4)
return (input[0] & 0x3) + (input[1] & 0x38);
} else { // len == 6
CHECK_CONTINUATION_BYTE(1)
CHECK_CONTINUATION_BYTE(2)
CHECK_CONTINUATION_BYTE(3)
CHECK_CONTINUATION_BYTE(4)
CHECK_CONTINUATION_BYTE(5)
return (input[0] & 0x1) + (input[1] & 0x3c);
}
return 0; // not reached
#undef CHECK_CONTINUATION_BYTE
}
// return count of bytes written
// buffer needs to be 6 bytes long
// does not reject UTF-16 surrogates codepoints
static inline int termpaintp_encode_to_utf8(int codepoint, unsigned char *buf) {
#define STORE_AND_SHIFT(index) \
buf[index] = (codepoint & 0b00111111) | 0x80; \
codepoint = codepoint >> 6;
if (codepoint > 0x7FFFFFFF) {
// out of range
return 0;
} else if (codepoint >= 0x04000000) {
STORE_AND_SHIFT(5)
STORE_AND_SHIFT(4)
STORE_AND_SHIFT(3)
STORE_AND_SHIFT(2)
STORE_AND_SHIFT(1)
buf[0] = 0b11111100 | codepoint;
return 6;
} else if (codepoint >= 0x00200000) {
STORE_AND_SHIFT(4)
STORE_AND_SHIFT(3)
STORE_AND_SHIFT(2)
STORE_AND_SHIFT(1)
buf[0] = 0b11111000 | codepoint;
return 5;
} else if (codepoint >= 0x00010000) {
STORE_AND_SHIFT(3)
STORE_AND_SHIFT(2)
STORE_AND_SHIFT(1)
buf[0] = 0b11110000 | codepoint;
return 4;
} else if (codepoint >= 0x00000800) {
STORE_AND_SHIFT(2)
STORE_AND_SHIFT(1)
buf[0] = 0b11100000 | codepoint;
return 3;
} else if (codepoint >= 0x00000080) {
STORE_AND_SHIFT(1)
buf[0] = 0b11000000 | codepoint;
return 2;
} else {
buf[0] = codepoint;
return 1;
}
#undef STORE_AND_SHIFT
}
// UTF-16 sneaked in here too
static inline _Bool termpaintp_utf16_is_high_surrogate(uint16_t codeunit) {
return (codeunit >= 0xD800) && (codeunit <= 0xDBFF);
}
static inline _Bool termpaintp_utf16_is_low_surrogate(uint16_t codeunit) {
return (codeunit >= 0xDC00) && (codeunit <= 0xDFFF);
}
static inline int termpaintp_utf16_combine(uint16_t high, uint16_t low) {
return 0x10000 + (((high - 0xD800) << 10) | (low - 0xDC00));
}
static inline unsigned termpaintp_utf16_split(int codepoint) {
if (codepoint <= 0xffff) {
return codepoint;
} else {
codepoint -= 0x10000;
return (0xDC00 + (codepoint & 0x3ff)) << 16 | (0xD800 + (codepoint >> 10));
}
}
#endif
termpaint-0.3.1/termpaintx.c 0000664 0000000 0000000 00000067352 14773035472 0016106 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#define _GNU_SOURCE
#include "termpaintx.h"
#ifdef USE_TK_DEBUGLOG
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#if __GNUC__
// Trying to avoid this warning with e.g. bit manipulations using defines from the standard headers is just too ugly
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
#ifndef nullptr
#define nullptr ((void*)0)
#endif
#define FDPTR(var) ((termpaint_integration_fd*)var)
typedef struct termpaint_integration_fd_ {
termpaint_integration base;
char *options;
// In rare situations, read and write MUST use different fds to be able to communicate with the terminal
int fd_read;
int fd_write;
bool auto_close; // if true fd_read == fd_write is assumed
struct termios original_terminal_attributes;
bool callback_requested;
bool awaiting_response;
bool poll_sigwinch;
bool inline_active;
int inline_height;
termpaint_terminal *terminal;
termpaintx_ttyrescue *rescue;
} termpaint_integration_fd;
static bool sigwinch_set;
static int sigwinch_pipe[2];
static void termpaintx_sig_winch_pipe_handler(int sig, siginfo_t *info, void *ucontext) {
(void)sig; (void)info; (void)ucontext;
char dummy = ' ';
(void)!write(sigwinch_pipe[1], &dummy, 1); // nothing much we can do, signal just gets lost then...
}
static void termpaintp_setup_winch(void) {
if (!sigwinch_set) {
bool ok = true;
#ifdef __linux__
ok &= (pipe2(sigwinch_pipe, O_CLOEXEC | O_NONBLOCK) == 0);
#else
ok &= (pipe(sigwinch_pipe) == 0);
ok &= (fcntl(sigwinch_pipe[0], F_SETFD, FD_CLOEXEC) == 0);
ok &= (fcntl(sigwinch_pipe[1], F_SETFD, FD_CLOEXEC) == 0);
ok &= (fcntl(sigwinch_pipe[0], F_SETFL, O_NONBLOCK) == 0);
ok &= (fcntl(sigwinch_pipe[1], F_SETFL, O_NONBLOCK) == 0);
#endif
if (!ok) {
return;
}
struct sigaction act;
if (sigfillset(&act.sa_mask) != 0) {
return;
}
act.sa_flags = SA_RESTART | SA_SIGINFO;
act.sa_sigaction = &termpaintx_sig_winch_pipe_handler;
if (sigaction(SIGWINCH, &act, NULL) != 0) {
return;
}
sigwinch_set = true;
}
}
static bool termpaintp_is_file_rw(int fd) {
int ret = fcntl(fd, F_GETFL);
return ret != -1 && (ret & O_ACCMODE) == O_RDWR;
}
static bool termpaintp_is_file_readable(int fd) {
int ret = fcntl(fd, F_GETFL);
return ret != -1 && ((ret & O_ACCMODE) == O_RDWR || (ret & O_ACCMODE) == O_RDONLY);
}
static bool termpaintp_is_file_writable(int fd) {
int ret = fcntl(fd, F_GETFL);
return ret != -1 && ((ret & O_ACCMODE) == O_RDWR || (ret & O_ACCMODE) == O_WRONLY);
}
static bool termpaintp_is_terminal_fd_pair(int fd_read, int fd_write) {
if (isatty(fd_read) && isatty(fd_write)
&& termpaintp_is_file_readable(fd_read) && termpaintp_is_file_writable(fd_write)) {
struct stat statbuf_r;
struct stat statbuf_w;
if (fstat(fd_read, &statbuf_r) == 0 && fstat(fd_write, &statbuf_w) == 0) {
if (statbuf_r.st_rdev == statbuf_w.st_rdev
&& statbuf_r.st_dev == statbuf_w.st_dev
&& statbuf_r.st_ino == statbuf_w.st_ino) {
return true;
}
}
}
return false;
}
_Bool termpaintx_full_integration_available(void) {
_Bool from_std_fd = false;
from_std_fd = (isatty(0) && termpaintp_is_file_rw(0))
|| (isatty(1) && termpaintp_is_file_rw(1))
|| (isatty(2) && termpaintp_is_file_rw(2));
if (from_std_fd) {
return true;
}
// also try controlling terminal
int fd = open("/dev/tty", O_RDONLY | O_NOCTTY | FD_CLOEXEC);
if (fd != -1) {
close(fd);
return true;
}
// as last resort check if (0, 1) or (0, 2) are matching read/write pairs pointing to the same terminal
if (termpaintp_is_terminal_fd_pair(0, 1)) {
return true;
}
if (termpaintp_is_terminal_fd_pair(0, 2)) {
return true;
}
return false;
}
termpaint_integration *termpaintx_full_integration(const char *options) {
int fd = -1;
int fd_write = -1; // only if differs
_Bool auto_close = false;
bool might_be_controlling_terminal = true;
if (isatty(0) && termpaintp_is_file_rw(0)) {
fd = 0;
} else if (isatty(1) && termpaintp_is_file_rw(1)) {
fd = 1;
} else if (isatty(2) && termpaintp_is_file_rw(2)) {
fd = 2;
} else {
fd = open("/dev/tty", O_RDWR | O_NOCTTY | FD_CLOEXEC);
if (fd != -1) {
auto_close = true;
} else {
might_be_controlling_terminal = false;
// as last resort check if (0, 1) or (0, 2) are matching read/write pairs pointing to the same terminal
if (termpaintp_is_terminal_fd_pair(0, 1)) {
fd = 0;
fd_write = 1;
} else if (termpaintp_is_terminal_fd_pair(0, 2)) {
fd = 0;
fd_write = 2;
} else {
return nullptr;
}
}
}
termpaint_integration *ret = (fd_write == -1) ? termpaintx_full_integration_from_fd(fd, auto_close, options)
: termpaintx_full_integration_from_fds(fd, fd_write, options);
if (might_be_controlling_terminal) {
termpaintp_setup_winch();
FDPTR(ret)->poll_sigwinch = true;
}
return ret;
}
termpaint_integration *termpaintx_full_integration_from_controlling_terminal(const char *options) {
int fd = -1;
fd = open("/dev/tty", O_RDWR | O_NOCTTY | FD_CLOEXEC);
if (fd == -1) {
return nullptr;
}
termpaint_integration *ret = termpaintx_full_integration_from_fd(fd, true, options);
termpaintp_setup_winch();
FDPTR(ret)->poll_sigwinch = true;
return ret;
}
static void fd_free(termpaint_integration* integration) {
termpaint_integration_fd* fd_data = FDPTR(integration);
// If terminal auto detection or another operation with response is cut short
// by a close the reponse will leak out into the next application.
// We can't reliably prevent that here, but this kludge can reduce the likelyhood
// by just discarding input for a short amount of time.
if (fd_data->awaiting_response) {
struct timespec start_time;
clock_gettime(CLOCK_REALTIME, &start_time);
while (true) {
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
long time_waited_ms = (now.tv_sec - start_time.tv_sec) * 1000
+ now.tv_nsec / 1000000 - start_time.tv_nsec / 1000000;
if (time_waited_ms >= 100 || time_waited_ms < 0) {
break;
}
int ret;
struct pollfd info;
info.fd = fd_data->fd_read;
info.events = POLLIN;
ret = poll(&info, 1, 100 - time_waited_ms);
if (ret == 1) {
char buff[1000];
int amount = (int)read(fd_data->fd_read, buff, 999);
if (amount < 0) {
break;
}
}
}
}
if (fd_data->rescue) {
termpaintx_ttyrescue_stop(fd_data->rescue);
fd_data->rescue = nullptr;
}
tcsetattr (fd_data->fd_read, TCSAFLUSH, &fd_data->original_terminal_attributes);
if (fd_data->auto_close && fd_data->fd_read != -1) {
// assumnes that auto_close will only be true if fd_read == fd_write
close(fd_data->fd_read);
}
free(fd_data->options);
termpaint_integration_deinit(&fd_data->base);
free(fd_data);
}
static void fd_flush(termpaint_integration* integration) {
(void)integration;
// no buffering yet
}
static void fd_mark_bad(termpaint_integration* integration) {
FDPTR(integration)->fd_read = -1;
FDPTR(integration)->fd_write = -1;
}
static _Bool fd_is_bad(termpaint_integration* integration) {
return FDPTR(integration)->fd_read == -1;
}
static void fd_write_data(termpaint_integration* integration, const char *data, int length) {
ssize_t written = 0;
ssize_t ret;
errno = 0;
while (written != length) {
ret = write(FDPTR(integration)->fd_write, data+written, length-written);
if (ret > 0) {
written += ret;
} else {
// error handling?
if (errno == EAGAIN || errno == EWOULDBLOCK) {
// fatal, non blocking is not supported by this integration
fd_mark_bad(integration);
return;
}
if (errno == EIO || errno == ENOSPC) {
// fatal?
fd_mark_bad(integration);
return;
}
if (errno == EBADF || errno == EINVAL || errno == EPIPE) {
// fatal, or fd is gone bad
fd_mark_bad(integration);
return;
}
if (errno == EINTR) {
continue;
}
}
}
}
static void fd_request_callback(struct termpaint_integration_ *integration) {
FDPTR(integration)->callback_requested = true;
}
static void fd_awaiting_response(struct termpaint_integration_ *integration) {
FDPTR(integration)->awaiting_response = true;
}
static bool termpaintp_has_option(const char *options, const char *name) {
const char *p = options;
int name_len = strlen(name);
while (1) {
const char *found = strstr(p, name);
if (!found) {
break;
}
if (found == options || found[-1] == ' ') {
if (found[name_len] == 0 || found[name_len] == ' ') {
return true;
}
}
p = found + name_len;
}
return false;
}
static bool termpaintp_fd_set_termios(int fd, const char *options) {
struct termios tattr;
if (tcgetattr(fd, &tattr) < 0) {
return false;
}
tattr.c_iflag |= IGNBRK|IGNPAR;
tattr.c_iflag &= ~(BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXOFF);
tattr.c_oflag &= ~(OPOST|ONLCR|OCRNL|ONOCR|ONLRET);
tattr.c_lflag &= ~(ICANON|IEXTEN|ECHO);
tattr.c_cc[VMIN] = 1;
tattr.c_cc[VTIME] = 0;
bool allow_interrupt = termpaintp_has_option(options, "+kbdsigint");
bool allow_quit = termpaintp_has_option(options, "+kbdsigquit");
bool allow_suspend = termpaintp_has_option(options, "+kbdsigtstp");
if (!(allow_interrupt || allow_quit || allow_suspend)) {
tattr.c_lflag &= ~ISIG;
} else {
if (!allow_interrupt) {
tattr.c_cc[VINTR] = 0;
}
if (!allow_quit) {
tattr.c_cc[VQUIT] = 0;
}
if (!allow_suspend) {
tattr.c_cc[VSUSP] = 0;
}
}
if (tcsetattr (fd, TCSAFLUSH, &tattr) < 0) {
return false;
}
return true;
}
bool termpaintx_fd_set_termios(int fd, const char *options) {
return termpaintp_fd_set_termios(fd, options);
}
static termpaint_integration *termpaintp_full_integration_from_fds(int fd_read, int fd_write, _Bool auto_close, const char *options) {
// NOTE: If fd_read != fd_write then auto_close must be false.
termpaint_integration_fd *ret = calloc(1, sizeof(termpaint_integration_fd));
if (!ret) {
(void)!write(2, "Out of memory\n", 14); // ignore error, exiting soon anyway.
abort();
}
termpaint_integration_init(&ret->base, fd_free, fd_write_data, fd_flush);
termpaint_integration_set_is_bad(&ret->base, fd_is_bad);
termpaint_integration_set_request_callback(&ret->base, fd_request_callback);
termpaint_integration_set_awaiting_response(&ret->base, fd_awaiting_response);
ret->options = strdup(options);
ret->fd_read = fd_read;
ret->fd_write = fd_write;
ret->auto_close = auto_close;
ret->callback_requested = false;
ret->awaiting_response = false;
tcgetattr(ret->fd_read, &ret->original_terminal_attributes);
termpaintp_fd_set_termios(ret->fd_read, options);
return (termpaint_integration*)ret;
}
termpaint_integration *termpaintx_full_integration_from_fd(int fd, _Bool auto_close, const char *options) {
return termpaintp_full_integration_from_fds(fd, fd, auto_close, options);
}
termpaint_integration *termpaintx_full_integration_from_fds(int fd_read, int fd_write, const char *options) {
return termpaintp_full_integration_from_fds(fd_read, fd_write, false, options);
}
void termpaintx_full_integration_wait_for_ready(termpaint_integration *integration) {
termpaint_integration_fd *t = FDPTR(integration);
while (termpaint_terminal_auto_detect_state(t->terminal) == termpaint_auto_detect_running) {
if (!termpaintx_full_integration_do_iteration(integration)) {
// some kind of error
break;
}
}
}
void termpaintx_full_integration_wait_for_ready_with_message(termpaint_integration *integration, int milliseconds, const char* message) {
termpaint_integration_fd *t = FDPTR(integration);
while (termpaint_terminal_auto_detect_state(t->terminal) == termpaint_auto_detect_running) {
if (milliseconds > 0) {
if (!termpaintx_full_integration_do_iteration_with_timeout(integration, &milliseconds)) {
// some kind of error
break;
}
if (milliseconds <= 0) {
fd_write_data(integration, message, strlen(message));
}
} else {
if (!termpaintx_full_integration_do_iteration(integration)) {
// some kind of error
break;
}
}
}
}
bool termpaintx_full_integration_terminal_size(termpaint_integration *integration, int *width, int *height) {
if (fd_is_bad(integration) || !isatty(FDPTR(integration)->fd_read)) {
return false;
}
return termpaintx_fd_terminal_size(FDPTR(integration)->fd_read, width, height);
}
void termpaintx_full_integration_set_terminal(termpaint_integration *integration, termpaint_terminal *terminal) {
termpaint_integration_fd *t = FDPTR(integration);
t->terminal = terminal;
}
static void termpaintp_handle_self_pipe(termpaint_integration_fd *t, struct pollfd *pfd) {
if (pfd->revents == POLLIN) {
// drain signaling pipe
char buff[1000];
int ret = read(sigwinch_pipe[0], buff, 999);
if (ret < 0 && ret != EINTR && ret != EAGAIN && ret != EWOULDBLOCK) {
// something broken, don't try again
sigwinch_set = false;
}
int width, height;
if (termpaintx_full_integration_terminal_size(&t->base, &width, &height)) {
if (t->inline_active && t->inline_height && height > t->inline_height) {
height = t->inline_height;
}
termpaint_surface* surface = termpaint_terminal_get_surface(t->terminal);
termpaint_surface_resize(surface, width, height);
}
} else {
// something broken, don't try again
sigwinch_set = false;
}
}
bool termpaintx_full_integration_do_iteration(termpaint_integration *integration) {
termpaint_integration_fd *t = FDPTR(integration);
char buff[1000];
if (t->poll_sigwinch && sigwinch_set) {
struct pollfd info[2];
info[0].fd = t->fd_read;
info[0].events = POLLIN;
info[1].fd = sigwinch_pipe[0];
info[1].events = POLLIN;
int ret = poll(info, 2, -1);
if (ret < 0 && errno == EINTR) {
return true;
}
if (ret > 0 && info[1].revents != 0) {
termpaintp_handle_self_pipe(t, &info[1]);
return true;
}
}
int amount = (int)read(t->fd_read, buff, 999);
if (amount < 0) {
if (errno != EINTR && errno != EWOULDBLOCK) {
return false;
} else {
return true;
}
}
t->awaiting_response = false;
termpaint_terminal_add_input_data(t->terminal, buff, amount);
if (t->callback_requested) {
t->callback_requested = false;
struct pollfd info;
info.fd = t->fd_read;
info.events = POLLIN;
int ret = poll(&info, 1, 100);
if (ret == 1) {
int amount = (int)read(t->fd_read, buff, 999);
if (amount < 0) {
if (errno != EINTR && errno != EWOULDBLOCK) {
return false;
} else {
return true;
}
}
t->awaiting_response = false;
termpaint_terminal_add_input_data(t->terminal, buff, amount);
}
termpaint_terminal_callback(t->terminal);
}
return true;
}
bool termpaintx_full_integration_do_iteration_with_timeout(termpaint_integration *integration, int *milliseconds) {
termpaint_integration_fd *t = FDPTR(integration);
char buff[1000];
struct timespec start_time;
clock_gettime(CLOCK_REALTIME, &start_time);
int ret;
{
int count = 1;
struct pollfd info[2];
info[0].fd = t->fd_read;
info[0].events = POLLIN;
if (t->poll_sigwinch && sigwinch_set) {
info[1].fd = sigwinch_pipe[0];
info[1].events = POLLIN;
++count;
}
ret = poll(info, count, *milliseconds);
if (ret < 0 && errno == EINTR) {
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
*milliseconds -= ((now.tv_sec - start_time.tv_sec) * 1000
+ now.tv_nsec / 1000000 - start_time.tv_nsec / 1000000);
return true;
}
if (count >= 2 && ret > 0 && info[1].revents != 0) {
termpaintp_handle_self_pipe(t, &info[1]);
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
*milliseconds -= ((now.tv_sec - start_time.tv_sec) * 1000
+ now.tv_nsec / 1000000 - start_time.tv_nsec / 1000000);
return true;
}
}
if (ret == 1) {
int amount = (int)read(t->fd_read, buff, 999);
if (amount < 0) {
if (errno != EINTR && errno != EWOULDBLOCK) {
return false;
} else {
return true;
}
}
t->awaiting_response = false;
termpaint_terminal_add_input_data(t->terminal, buff, amount);
if (t->callback_requested) {
t->callback_requested = false;
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
long remaining = *milliseconds
- ((now.tv_sec - start_time.tv_sec) * 1000
+ now.tv_nsec / 1000000 - start_time.tv_nsec / 1000000);
if (remaining > 0) {
struct pollfd info;
info.fd = t->fd_read;
info.events = POLLIN;
ret = poll(&info, 1, remaining < 100 ? remaining : 100);
}
if (ret == 1) {
int amount = (int)read(t->fd_read, buff, 999);
if (amount < 0) {
if (errno != EINTR && errno != EWOULDBLOCK) {
return false;
} else {
return true;
}
}
t->awaiting_response = false;
termpaint_terminal_add_input_data(t->terminal, buff, amount);
}
termpaint_terminal_callback(t->terminal);
}
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
*milliseconds -= (int)((now.tv_sec - start_time.tv_sec) * 1000
+ now.tv_nsec / 1000000 - start_time.tv_nsec / 1000000);
} else {
*milliseconds = 0;
}
return true;
}
bool termpaintx_fd_terminal_size(int fd, int *width, int *height) {
struct winsize s;
if (ioctl(fd, TIOCGWINSZ, &s) < 0) {
return false;
}
*width = s.ws_col;
*height = s.ws_row;
return true;
}
const struct termios *termpaintx_full_integration_original_terminal_attributes(termpaint_integration *integration) {
termpaint_integration_fd *t = FDPTR(integration);
return &t->original_terminal_attributes;
}
void termpaintx_full_integration_apply_input_quirks(termpaint_integration *integration) {
termpaint_integration_fd *t = FDPTR(integration);
termpaint_terminal_auto_detect_apply_input_quirks(t->terminal, t->original_terminal_attributes.c_cc[VERASE] == 0x08);
}
static void fd_restore_sequence_updated(struct termpaint_integration_ *integration, const char *data, int length) {
termpaint_integration_fd *t = FDPTR(integration);
if (t->rescue) {
termpaintx_ttyrescue_update(t->rescue, data, length);
}
}
bool termpaintx_full_integration_ttyrescue_start(termpaint_integration *integration) {
termpaint_integration_fd *t = FDPTR(integration);
if (t->rescue || !t->terminal) return false;
t->rescue = termpaintx_ttyrescue_start_or_nullptr(t->fd_write, termpaint_terminal_restore_sequence(t->terminal));
if (t->rescue) {
termpaint_integration_set_restore_sequence_updated(integration, fd_restore_sequence_updated);
termpaintx_ttyrescue_set_restore_termios(t->rescue, &t->original_terminal_attributes);
return true;
}
return false;
}
static termpaint_integration *termpaintp_full_integration_setup_terminal_common(const char *options,
void (*event_handler)(void *, termpaint_event *),
void *event_handler_user_data,
termpaint_terminal **terminal_out) {
termpaint_integration *integration = termpaintx_full_integration(options);
if (!integration) {
const char* error = "Error: Terminal not available!";
(void)!write(1, error, strlen(error)); // already printing an error message
return nullptr;
}
termpaint_terminal *terminal = termpaint_terminal_new(integration);
termpaintx_full_integration_set_terminal(integration, terminal);
termpaint_terminal_set_event_cb(terminal, event_handler, event_handler_user_data);
termpaint_terminal_auto_detect(terminal);
termpaintx_full_integration_wait_for_ready_with_message(integration, 10000,
"Terminal auto detection is taking unusually long, press space to abort.");
termpaintx_full_integration_apply_input_quirks(integration);
*terminal_out = terminal;
return integration;
}
termpaint_integration *termpaintx_full_integration_setup_terminal_fullscreen(const char *options,
void (*event_handler)(void *, termpaint_event *),
void *event_handler_user_data,
termpaint_terminal **terminal_out) {
termpaint_terminal *terminal;
termpaint_integration *integration = termpaintp_full_integration_setup_terminal_common(options,
event_handler,
event_handler_user_data,
&terminal);
if (!integration) {
return nullptr;
}
int width = 80, height = 25;
termpaintx_full_integration_terminal_size(integration, &width, &height);
termpaint_terminal_setup_fullscreen(terminal, width, height, options);
termpaintx_full_integration_ttyrescue_start(integration);
*terminal_out = terminal;
return integration;
}
termpaint_integration *termpaintx_full_integration_setup_terminal_inline(const char *options,
int lines,
void (*event_handler)(void *, termpaint_event *),
void *event_handler_user_data,
termpaint_terminal **terminal_out) {
termpaint_terminal *terminal;
termpaint_integration *integration = termpaintp_full_integration_setup_terminal_common(options,
event_handler,
event_handler_user_data,
&terminal);
if (!integration) {
return nullptr;
}
termpaint_integration_fd* fd_data = FDPTR(integration);
fd_data->inline_height = lines;
fd_data->inline_active = true;
int width = 80, height = 25;
termpaintx_full_integration_terminal_size(integration, &width, &height);
if (height > lines) {
height = lines;
}
termpaint_terminal_setup_inline(terminal, width, height, options);
termpaintx_full_integration_ttyrescue_start(integration);
*terminal_out = terminal;
return integration;
}
void termpaintx_full_integration_set_inline(termpaint_integration *integration, _Bool enabled, int height) {
termpaint_integration_fd* fd_data = FDPTR(integration);
if (height > 0) {
fd_data->inline_height = height;
}
termpaint_terminal_set_inline(fd_data->terminal, enabled);
fd_data->inline_active = enabled;
int term_width, term_height;
if (termpaintx_full_integration_terminal_size(integration, &term_width, &term_height)) {
if (fd_data->inline_active && fd_data->inline_height && term_height > fd_data->inline_height) {
term_height = fd_data->inline_height;
}
termpaint_surface* surface = termpaint_terminal_get_surface(fd_data->terminal);
termpaint_surface_resize(surface, term_width, term_height);
}
}
static void termpaintx_dummy_log(struct termpaint_integration_ *integration, char *data, int length) {
(void)integration;
(void)data;
(void)length;
}
#ifdef USE_TK_DEBUGLOG
#include "debugwin.py.inc"
static int logfd = -1;
static void termpaintx_fd_log(struct termpaint_integration_ *integration, char *data, int length) {
(void)integration;
write(logfd, data, length);
}
extern char **environ;
termpaint_logging_func termpaintx_enable_tk_logging(void) {
if (logfd >= 0) {
return termpaintx_fd_log;
}
int pipeends[2];
if (pipe2(pipeends, O_CLOEXEC) < 0) {
return termpaintx_dummy_log;
}
logfd = pipeends[1];
int readend = pipeends[0];
posix_spawnattr_t attr;
posix_spawn_file_actions_t file_actions;
posix_spawn_file_actions_init(&file_actions);
if (readend != 1) {
posix_spawn_file_actions_addclose(&file_actions, 1);
}
if (readend != 2) {
posix_spawn_file_actions_addclose(&file_actions, 2);
}
if (readend != 0) {
posix_spawn_file_actions_addclose(&file_actions, 0);
posix_spawn_file_actions_adddup2(&file_actions, readend, 0);
}
posix_spawnattr_init(&attr);
posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSIGDEF);
sigset_t mask;
sigfillset(&mask);
posix_spawnattr_getsigdefault(&attr, &mask);
char * argv[] = {
"python3",
"-E",
"-c", (char*)debugwin,
nullptr
};
posix_spawnp(nullptr, "python3", &file_actions, &attr,
argv, environ);
posix_spawn_file_actions_destroy(&file_actions);
posix_spawnattr_destroy(&attr);
return termpaintx_fd_log;
}
#else
termpaint_logging_func termpaintx_enable_tk_logging(void) {
return termpaintx_dummy_log;
}
#endif
termpaint-0.3.1/termpaintx.h 0000664 0000000 0000000 00000005361 14773035472 0016103 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINTX_INCLUDED
#define TERMPAINT_TERMPAINTX_INCLUDED
#include "termpaint.h"
#ifdef __cplusplus
extern "C" {
#endif
_tERMPAINT_PUBLIC _Bool termpaintx_full_integration_available(void);
_tERMPAINT_PUBLIC termpaint_integration *termpaintx_full_integration(const char *options);
_tERMPAINT_PUBLIC termpaint_integration *termpaintx_full_integration_from_controlling_terminal(const char *options);
_tERMPAINT_PUBLIC termpaint_integration *termpaintx_full_integration_from_fd(int fd, _Bool auto_close, const char *options);
_tERMPAINT_PUBLIC termpaint_integration *termpaintx_full_integration_from_fds(int fd_read, int fd_write, const char *options);
_tERMPAINT_PUBLIC termpaint_integration *termpaintx_full_integration_setup_terminal_fullscreen(const char *options, void (*event_handler)(void *, termpaint_event *), void *event_handler_user_data, termpaint_terminal **terminal_out);
_tERMPAINT_PUBLIC termpaint_integration *termpaintx_full_integration_setup_terminal_inline(const char *options, int lines, void (*event_handler)(void *, termpaint_event *), void *event_handler_user_data, termpaint_terminal **terminal_out);
_tERMPAINT_PUBLIC void termpaintx_full_integration_set_inline(termpaint_integration *integration, _Bool enabled, int height);
_tERMPAINT_PUBLIC void termpaintx_full_integration_wait_for_ready(termpaint_integration *integration);
_tERMPAINT_PUBLIC void termpaintx_full_integration_wait_for_ready_with_message(termpaint_integration *integration, int milliseconds, const char* message);
_tERMPAINT_PUBLIC void termpaintx_full_integration_apply_input_quirks(termpaint_integration *integration);
_tERMPAINT_PUBLIC void termpaintx_full_integration_set_terminal(termpaint_integration *integration, termpaint_terminal *terminal);
_tERMPAINT_PUBLIC _Bool termpaintx_full_integration_do_iteration(termpaint_integration *integration);
_tERMPAINT_PUBLIC _Bool termpaintx_full_integration_do_iteration_with_timeout(termpaint_integration *integration, int *milliseconds);
_tERMPAINT_PUBLIC _Bool termpaintx_full_integration_terminal_size(termpaint_integration *integration, int *width, int *height);
_tERMPAINT_PUBLIC _Bool termpaintx_full_integration_ttyrescue_start(termpaint_integration *integration);
_tERMPAINT_PUBLIC const struct termios *termpaintx_full_integration_original_terminal_attributes(termpaint_integration *integration);
_tERMPAINT_PUBLIC _Bool termpaintx_fd_set_termios(int fd, const char *options);
_tERMPAINT_PUBLIC _Bool termpaintx_fd_terminal_size(int fd, int *width, int *height);
typedef void (*termpaint_logging_func)(struct termpaint_integration_ *integration, char *data, int length);
_tERMPAINT_PUBLIC termpaint_logging_func termpaintx_enable_tk_logging(void);
#ifdef __cplusplus
}
#endif
#endif
termpaint-0.3.1/termpaintx_ttyrescue.c 0000664 0000000 0000000 00000036002 14773035472 0020201 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#define _GNU_SOURCE
#include "termpaintx_ttyrescue.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef __linux__
#include
// memfd
#include
#ifdef __NR_memfd_create
#include
#endif
#endif
#ifndef nullptr
#define nullptr ((void*)0)
#endif
_Static_assert(ATOMIC_INT_LOCK_FREE == 2, "lock free atomic_int needed");
#ifdef TERMPAINTP_VALGRIND
#include
#endif
#ifdef TERMPAINT_RESCUE_FEXEC
#include "ttyrescue_blob.inc"
#endif
#ifdef TERMPAINTP_VALGRIND
static void exit_wrapper(long tid, void (*fn)(int)) {
(void)tid;
// lazy resolving _exit by ld.so here crashes, so take it as preresolved pointer
fn(1);
}
#endif
#if defined(__linux__) && defined(__NR_memfd_create)
int termpaintp_memfd_create(const char *name, unsigned int flags, bool allow_exec) {
#ifdef MFD_EXEC
if (allow_exec) {
flags |= MFD_EXEC;
} else {
flags |= MFD_NOEXEC_SEAL;
}
#endif
int fd = (int)syscall(__NR_memfd_create, name, flags);
#ifdef MFD_EXEC
if (fd < 0 && errno == EINVAL) {
// Need to retry if kernel does not yet support MFD_EXEC / MFD_NOEXEC_SEAL.
flags &= ~(MFD_EXEC | MFD_NOEXEC_SEAL);
fd = (int)syscall(__NR_memfd_create, name, flags);
}
#endif
return fd;
}
#define HAVE_MEMFD 1
#endif
#define SEGLEN 8192
#define TTYRESCUE_FLAG_ATTACHED (1 << 0)
#define TTYRESCUE_FLAG_TERMIOS_SET (1 << 1)
struct termpaint_ipcseg {
atomic_int active;
atomic_int flags;
long termios_iflag;
long termios_oflag;
long termios_lflag;
long termios_vintr;
long termios_vmin;
long termios_vquit;
long termios_vstart;
long termios_vstop;
long termios_vsusp;
long termios_vtime;
char seq1[4000];
char seq2[4000];
};
_Static_assert(sizeof(struct termpaint_ipcseg) < SEGLEN, "termpaint_ipcseg does not fit IPC segment size");
int termpaintp_rescue_embedded(struct termpaint_ipcseg* ctlseg);
struct termpaintx_ttyrescue_ {
int fd;
struct termpaint_ipcseg* seg;
bool using_mmap;
};
#ifdef __GNUC__
__attribute__((format(printf, 1, 2)))
#endif
static char* termpaintp_asprintf(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
int len = vsnprintf(nullptr, 0, fmt, ap);
va_end(ap);
if (len < 0) {
return nullptr;
}
char *ret = malloc(len + 1);
if (!ret) {
return nullptr;
}
va_start(ap, fmt);
len = vsnprintf(ret, len + 1, fmt, ap);
va_end(ap);
if (len < 0) {
free(ret);
return nullptr;
}
return ret;
}
termpaintx_ttyrescue *termpaintx_ttyrescue_start_or_nullptr(int tty_fd, const char *restore_seq) {
termpaintx_ttyrescue *ret = calloc(1, sizeof(termpaintx_ttyrescue));
if (!ret) {
return nullptr;
}
ret->using_mmap = 0;
int pipe[2];
#ifdef SOCK_CLOEXEC
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, pipe) < 0) {
free(ret);
return nullptr;
}
#else
// This is racy, but systems that don't offer non racy apis seem to prefer it that way.
if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe) < 0) {
free(ret);
return nullptr;
}
fcntl(pipe[0], F_SETFD, FD_CLOEXEC);
fcntl(pipe[1], F_SETFD, FD_CLOEXEC);
fcntl(pipe[0], F_SETFL, O_NONBLOCK);
fcntl(pipe[1], F_SETFL, O_NONBLOCK);
#endif
int shmfd = -1;
#if HAVE_MEMFD
shmfd = termpaintp_memfd_create("ttyrescue ctl", MFD_CLOEXEC | MFD_ALLOW_SEALING, false);
if (shmfd < 0) {
shmfd = -1;
}
#endif
#if defined(__FreeBSD__)
if (shmfd == -1) {
shmfd = shm_open(SHM_ANON, O_RDWR | IPC_CREAT | IPC_EXCL, 0600); // FD_CLOEXEC is implied
if (shmfd < 0) {
shmfd = -1;
}
}
#endif
if (shmfd != -1) {
if (ftruncate(shmfd, SEGLEN) < 0) {
close(shmfd);
shmfd = -1;
} else {
ret->seg = mmap(0, SEGLEN, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
if (ret->seg == MAP_FAILED) {
close(shmfd);
shmfd = -1;
ret->seg = nullptr;
} else {
ret->using_mmap = true;
}
}
}
int shmid = -1;
if (shmfd == -1) {
shmid = shmget(IPC_PRIVATE, SEGLEN, 0600 | IPC_CREAT | IPC_EXCL);
ret->seg = shmat(shmid, 0, 0);
if (ret->seg == (void*)-1) {
ret->seg = nullptr;
shmctl(shmid, IPC_RMID, nullptr);
shmid = -1;
}
}
char *envvar = termpaintp_asprintf("TTYRESCUE_RESTORE=%s", restore_seq);
char *envvar2 = nullptr;
bool alloc_error = envvar == nullptr;
char *envp[3] = {envvar, nullptr, nullptr};
if (shmid != -1) {
envvar2 = termpaintp_asprintf("TTYRESCUE_SYSVSHMID=%i", shmid);
alloc_error |= envvar2 == nullptr;
envp[1] = envvar2;
}
if (shmfd != -1) {
envvar2 = strdup("TTYRESCUE_SHMFD=yes");
alloc_error |= envvar2 == nullptr;
envp[1] = envvar2;
}
if (alloc_error) {
close(pipe[0]);
close(pipe[1]);
free(envvar);
free(envvar2);
if (shmid != -1) {
shmctl(shmid, IPC_RMID, nullptr);
}
if (shmfd != -1) {
close(shmfd);
}
free(ret);
return nullptr;
}
termpaintx_ttyrescue_update(ret, restore_seq, strlen(restore_seq));
pid_t pid = fork();
if (pid < 0) {
close(pipe[0]);
close(pipe[1]);
free(envvar);
free(envvar2);
if (shmid != -1) {
shmdt(ret->seg);
shmctl(shmid, IPC_RMID, nullptr);
}
if (shmfd != -1) {
close(shmfd);
}
free(ret);
return nullptr;
} else if (pid) {
free(envvar);
free(envvar2);
close(pipe[0]);
ret->fd = pipe[1];
if (shmid != -1) {
struct pollfd info;
info.fd = ret->fd;
info.events = POLLIN;
int err;
do {
err = poll(&info, 1, -1);
} while (err == EINTR);
char buff[1];
(void)!read(ret->fd, buff, 1); // failure doesn't matter, course of action keeps same
shmctl(shmid, IPC_RMID, nullptr);
}
if (shmfd != -1) {
close(shmfd);
}
return ret;
} else {
close(pipe[1]);
// wanted file descriptors 0: control pipe(pipe[0]), 1: closed, 2: terminal(tty_fd), 3: control segment (shmfd)
// first move file descriptors we intend to keep out of the way
if (tty_fd == 0) {
tty_fd = dup(tty_fd);
}
if (shmfd == 0) {
shmfd = dup(shmfd);
}
// setup fd 0
if (pipe[0] == 0) {
fcntl(0, F_SETFD, 0); // Unset O_CLOEXEC
} else {
dup2(pipe[0], 0);
}
if (shmfd == 2) {
shmfd = dup(shmfd);
}
if (tty_fd == 2) {
fcntl(pipe[0], F_SETFD, 0); // Unset O_CLOEXEC
} else {
dup2(tty_fd, 2);
}
if (shmfd != -1) {
if (shmfd == 3) {
fcntl(3, F_SETFD, 0); // Unset O_CLOEXEC
} else {
dup2(shmfd, 3);
}
}
close(1);
int from = ((shmfd != -1) ? 4 : 3);
#if defined(__FreeBSD__)
closefrom(from);
#else
int max_fd = sysconf(_SC_OPEN_MAX);
for (int i = from; i < max_fd; i++) {
close(i);
}
#endif
char *argv[] = {"ttyrescue", NULL};
const char* path = TERMPAINT_RESCUE_PATH;
char tmp[sizeof(TERMPAINT_RESCUE_PATH) + sizeof("ttyrescue") + 1];
for (const char *item = path; *item;) {
char *end = strchr(item, ':');
ptrdiff_t len;
if (end) {
len = end - item;
} else {
len = strlen(item);
}
if (len > 0) {
memcpy(tmp, item, len);
tmp[len] = '/';
tmp[len+1] = '\0';
strcat(tmp, "ttyrescue");
execve(tmp, argv, envp);
}
if (end) {
item = end + 1;
} else {
break;
}
}
#ifdef TERMPAINT_RESCUE_FEXEC
#ifdef __linux__
if (shmfd != -1) {
int exefd = termpaintp_memfd_create("ttyrescue (embedded)", MFD_CLOEXEC | MFD_ALLOW_SEALING, true);
if (write(exefd, ttyrescue_blob, sizeof(ttyrescue_blob)) == sizeof(ttyrescue_blob)) {
argv[0] = "ttyrescue (embedded)";
fexecve(exefd, argv, envp);
close(exefd);
}
}
#else
#error ttyrescue-fexec-blob option not available on this platform: not ported yet
#endif
#endif
// if that does not work use internal fallback.
extern char **environ;
environ = envp;
#ifdef __linux__
prctl(PR_SET_NAME, "ttyrescue embed", 0, 0, 0);
int fd = open("/proc/self/stat", O_RDONLY, 0);
if (fd) {
char buffer[1000];
int idx = 0;
int max = 0;
int argn = 0;
intptr_t argc_base = -1;
intptr_t argc_end = -1;
enum { S_A1, S_PAREN1, S_COMM, S_SPACEX, S_ARGX } state = S_A1;
while (1) {
if (idx+1 >= max) {
max = read(fd, buffer, 1000);
if (max <= 0) {
break;
}
idx = 0;
} else {
++idx;
}
if (state == S_A1) {
if (buffer[idx] == ' ') {
state = S_PAREN1;
}
} else if (state == S_PAREN1) {
if (buffer[idx] == '(') {
state = S_COMM;
}
} else if (state == S_COMM) {
if (buffer[idx] == ')') {
state = S_SPACEX;
argn = 2;
}
} else if (state == S_SPACEX) {
if (buffer[idx] != ' ') {
++argn;
state = S_ARGX;
if (argn == 48) { // arg_start
argc_base = buffer[idx] - '0';
}
if (argn == 49) { // arg_end
argc_end = buffer[idx] - '0';
}
}
} else if (state == S_ARGX) {
if (buffer[idx] == ' ') {
state = S_SPACEX;
if (argn == 49) {
break;
}
} else {
if (argn == 48) { // arg_start
argc_base = argc_base * 10 + buffer[idx] - '0';
}
if (argn == 49) { // arg_end
argc_end = argc_end * 10 + buffer[idx] - '0';
}
}
}
}
close(fd);
if (argc_base != -1 && argc_end != -1 && argc_end > argc_base) {
#ifdef TERMPAINTP_VALGRIND
// Valgrind does not grok that this is supposed to work, use a cluebat
VALGRIND_MAKE_MEM_DEFINED(argc_base, argc_end - argc_base);
#endif
int datalen = 21;
// if datalen does not fit into the arg space, intentionally overwrite into
// the environment space to get the full name shown.
memcpy((void*)argc_base, "ttyrescue (embedded)", datalen);
// zero out the rest of the space, so ps doesn't show left over parts from old name
if (datalen <= argc_end - argc_base) {
memset((char*)argc_base + datalen, 0, argc_end - argc_base - datalen);
}
}
}
#endif
#ifdef TERMPAINTP_VALGRIND
VALGRIND_PRINTF("termpaint embedded ttyrescue running with valgrind. Maybe use --child-silent-after-fork=yes\n");
#endif
termpaintp_rescue_embedded(ret->seg);
#ifdef TERMPAINTP_VALGRIND
if (RUNNING_ON_VALGRIND) {
// There is no way to avoid leaking the main programs allocations
// Valgrind's leak check would report these, so instead exit this process without valgrind noticeing.
VALGRIND_PRINTF("termpaint embedded ttyrescue exited (suppressing valgrind reports in rescue process)\n");
(void)VALGRIND_NON_SIMD_CALL1(exit_wrapper, _exit);
}
#endif
_exit(1);
}
}
void termpaintx_ttyrescue_stop(termpaintx_ttyrescue *tpr) {
if (!tpr) {
return;
}
if (tpr->fd >= 0) {
#ifdef MSG_NOSIGNAL
send(tpr->fd, "~", 1, MSG_NOSIGNAL);
#else
send(tpr->fd, "~", 1, 0);
#endif
}
if (tpr->seg) {
if (tpr->using_mmap) {
munmap(tpr->seg, SEGLEN);
} else {
shmdt(tpr->seg);
}
}
free(tpr);
}
_Bool termpaintx_ttyrescue_update(termpaintx_ttyrescue *tpr, const char *data, int len) {
if (tpr->seg && len < (int)sizeof(tpr->seg->seq1)) {
// active is only written from this process. It's atomic to get memory_order_seq_cst and
// to avoid tearing
int offset = atomic_load(&tpr->seg->active);
if (offset == 0 || offset == offsetof(struct termpaint_ipcseg, seq2)) {
memcpy(tpr->seg->seq1, data, len);
tpr->seg->seq1[len] = 0;
atomic_store(&tpr->seg->active, offsetof(struct termpaint_ipcseg, seq1));
} else {
memcpy(tpr->seg->seq2, data, len);
tpr->seg->seq2[len] = 0;
atomic_store(&tpr->seg->active, offsetof(struct termpaint_ipcseg, seq2));
}
return 1;
}
return 0;
}
bool termpaintx_ttyrescue_set_restore_termios(termpaintx_ttyrescue *tpr, const struct termios *original_terminal_attributes) {
if (tpr->seg) {
tpr->seg->termios_iflag = original_terminal_attributes->c_iflag;
tpr->seg->termios_oflag = original_terminal_attributes->c_oflag;
tpr->seg->termios_lflag = original_terminal_attributes->c_lflag;
tpr->seg->termios_vintr = original_terminal_attributes->c_cc[VINTR];
tpr->seg->termios_vmin = original_terminal_attributes->c_cc[VMIN];
tpr->seg->termios_vquit = original_terminal_attributes->c_cc[VQUIT];
tpr->seg->termios_vstart = original_terminal_attributes->c_cc[VSTART];
tpr->seg->termios_vstop = original_terminal_attributes->c_cc[VSTOP];
tpr->seg->termios_vsusp = original_terminal_attributes->c_cc[VSUSP];
tpr->seg->termios_vtime = original_terminal_attributes->c_cc[VTIME];
atomic_fetch_or(&tpr->seg->flags, TTYRESCUE_FLAG_TERMIOS_SET);
}
return 0;
}
termpaint-0.3.1/termpaintx_ttyrescue.h 0000664 0000000 0000000 00000001741 14773035472 0020210 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#ifndef TERMPAINT_TERMPAINT_TTYRESCUE_INCLUDED
#define TERMPAINT_TERMPAINT_TTYRESCUE_INCLUDED
#include
#ifdef __cplusplus
#ifndef _Bool
#define _Bool bool
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__GNUC__) && defined(TERMPAINT_EXPORT_SYMBOLS)
#define _tERMPAINT_PUBLIC __attribute__((visibility("default")))
#else
#define _tERMPAINT_PUBLIC
#endif
struct termpaintx_ttyrescue_;
typedef struct termpaintx_ttyrescue_ termpaintx_ttyrescue;
_tERMPAINT_PUBLIC void termpaintx_ttyrescue_stop(termpaintx_ttyrescue *tpr);
_tERMPAINT_PUBLIC _Bool termpaintx_ttyrescue_update(termpaintx_ttyrescue *tpr, const char* data, int len);
_tERMPAINT_PUBLIC _Bool termpaintx_ttyrescue_set_restore_termios(termpaintx_ttyrescue *tpr, const struct termios *original_terminal_attributes);
_tERMPAINT_PUBLIC termpaintx_ttyrescue *termpaintx_ttyrescue_start_or_nullptr(int fd, const char *restore_seq);
#ifdef __cplusplus
}
#endif
#endif
termpaint-0.3.1/termquery.cpp 0000664 0000000 0000000 00000015473 14773035472 0016305 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: BSL-1.0
#include
#include
#include
#include
#include
#include
#include