../src/bte.cc

Bug Summary

File:	_build/../src/bte.cc
Warning:	line 8389, column 14 1st function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name bte.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/_build -resource-dir /usr/lib/llvm-16/lib/clang/16 -I src/libbte-2.91.so.0.6500.0.p -I src -I ../src -I . -I .. -I src/bte -I ../src/bte -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/pango-1.0 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/p11-kit-1 -I /usr/include/ctk-3.0 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -D _GLIBCXX_ASSERTIONS=1 -D _FILE_OFFSET_BITS=64 -D G_LOG_DOMAIN="BTE" -D LOCALEDIR="/usr/local/share/locale" -D BTE_DISABLE_DEPRECATION_WARNINGS -D BTE_COMPILATION -U PARSER_INCLUDE_NOP -D CDK_VERSION_MIN_REQUIRED=(G_ENCODE_VERSION(3,18)) -D CDK_VERSION_MAX_ALLOWED=(G_ENCODE_VERSION(3,20)) -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/13/../../../../include/x86_64-linux-gnu/c++/13 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-address-of-packed-member -Wno-missing-field-initializers -Wno-packed -Wno-switch-enum -Wno-unused-parameter -Wwrite-strings -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/rootdir/_build -ferror-limit 19 -fvisibility=hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-08-05-221400-10675-1 -x c++ ../src/bte.cc
1/*
* Copyright (C) 2001-2004,2009,2010 Red Hat, Inc.
* Copyright © 2008, 2009, 2010 Christian Persch
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

20#include "config.h"

22#include <math.h>
23#include <search.h>
24#include <stdlib.h>
25#include <string.h>
26#include <sys/ioctl.h>
27#include <errno(*__errno_location ()).h>
28#include <fcntl.h>
29#ifdef HAVE_SYS_TERMIOS_H
30#include <sys/termios.h>
31#endif

33#include <glib.h>
34#include <glib-unix1.h>
35#include <glib/gi18n-lib.h>

37#include <bte/bte.h>
38#include "bteinternal.hh"
39#include "bidi.hh"
40#include "buffer.h"
41#include "debug.h"
42#include "reaper.hh"
43#include "ring.hh"
44#include "ringview.hh"
45#include "caps.hh"
46#include "widget.hh"

48#ifdef HAVE_WCHAR_H
49#include <wchar.h>
50#endif
51#ifdef HAVE_SYS_SYSLIMITS_H
52#include <sys/syslimits.h>
53#endif
54#ifdef HAVE_SYS_WAIT_H
55#include <sys/wait.h>
56#endif
57#include <glib.h>
58#include <glib-object.h>
59#include <cdk/cdk.h>
60#include <ctk/ctk.h>
61#include <pango/pango.h>
62#include "keymap.h"
63#include "marshal.h"
64#include "btepty.h"
65#include "btectk.hh"
66#include "cxx-utils.hh"
67#include "gobject-glue.hh"

69#ifdef WITH_A11Y
70#include "bteaccess.h"
71#endif

73#include <new> /* placement new */

75using namespace std::literals;

77#ifndef HAVE_ROUND
78static inline double round(double x) {
if(x - floor(x) < 0.5) {
return floor(x);
} else {
return ceil(x);
}
84}
85#endif

87#define WORD_CHAR_EXCEPTIONS_DEFAULT"-#%&+,./=?@\\_~\302\267"sv "-#%&+,./=?@\\_~\302\267"sv

89#define I_(string)(g_intern_static_string(string)) (g_intern_static_string(string))

91#define BTE_DRAW_OPAQUE(1.0) (1.0)

93namespace bte {
94namespace terminal {

96static int _bte_unichar_width(gunichar c, int utf8_ambiguous_width);
97static void stop_processing(bte::terminal::Terminal* that);
98static void add_process_timeout(bte::terminal::Terminal* that);
99static void add_update_timeout(bte::terminal::Terminal* that);
100static void remove_update_timeout(bte::terminal::Terminal* that);

102static gboolean process_timeout (gpointer data) noexcept;
103static gboolean update_timeout (gpointer data) noexcept;
104static cairo_region_t *bte_cairo_get_clip_region (cairo_t *cr);

106/* these static variables are guarded by the CDK mutex */
107static guint process_timeout_tag = 0;
108static gboolean in_process_timeout;
109static guint update_timeout_tag = 0;
110static gboolean in_update_timeout;
111static GList *g_active_terminals;

113static int
114_bte_unichar_width(gunichar c, int utf8_ambiguous_width)
115{
      if (G_LIKELY (c < 0x80)(__builtin_expect (__extension__ ({ int _g_boolean_var_940; if
 (c < 0x80) _g_boolean_var_940 = 1; else _g_boolean_var_940
 = 0; _g_boolean_var_940; }), 1)))
              return 1;
      if (G_UNLIKELY (g_unichar_iszerowidth (c))(__builtin_expect (__extension__ ({ int _g_boolean_var_941; if
 (g_unichar_iszerowidth (c)) _g_boolean_var_941 = 1; else _g_boolean_var_941
 = 0; _g_boolean_var_941; }), 0)))
              return 0;
      if (G_UNLIKELY (g_unichar_iswide (c))(__builtin_expect (__extension__ ({ int _g_boolean_var_942; if
 (g_unichar_iswide (c)) _g_boolean_var_942 = 1; else _g_boolean_var_942
 = 0; _g_boolean_var_942; }), 0)))
              return 2;
      if (G_LIKELY (utf8_ambiguous_width == 1)(__builtin_expect (__extension__ ({ int _g_boolean_var_943; if
 (utf8_ambiguous_width == 1) _g_boolean_var_943 = 1; else _g_boolean_var_943
 = 0; _g_boolean_var_943; }), 1)))
              return 1;
      if (G_UNLIKELY (g_unichar_iswide_cjk (c))(__builtin_expect (__extension__ ({ int _g_boolean_var_944; if
 (g_unichar_iswide_cjk (c)) _g_boolean_var_944 = 1; else _g_boolean_var_944
 = 0; _g_boolean_var_944; }), 0)))
              return 2;
      return 1;
127}

129static void
130bte_g_array_fill(GArray *array, gconstpointer item, guint final_size)
131{
if (array->len >= final_size)
return;

final_size -= array->len;
do {
g_array_append_vals(array, item, 1);
} while (--final_size);
139}

141void
142Terminal::unset_widget() noexcept
143{
      m_real_widget = nullptr;
      m_terminal = nullptr;
      m_widget = nullptr;
147}

149// FIXMEchpe replace this with a method on BteRing
150BteRowData*
151Terminal::ring_insert(bte::grid::row_t position,
                              bool fill)
153{
BteRowData *row;
BteRing *ring = m_screen->row_data;
      bool const not_default_bg = (m_color_defaults.attr.back() != BTE_DEFAULT_BG257);

while (G_UNLIKELY (_bte_ring_next (ring) < position)(__builtin_expect (__extension__ ({ int _g_boolean_var_945; if
 (_bte_ring_next (ring) < position) _g_boolean_var_945 = 1
; else _g_boolean_var_945 = 0; _g_boolean_var_945; }), 0))) {
              row = _bte_ring_append (ring, get_bidi_flags());
              if (not_default_bg)
                      _bte_row_data_fill (row, &m_color_defaults, m_column_count);
}
      row = _bte_ring_insert (ring, position, get_bidi_flags());
      if (fill && not_default_bg)
              _bte_row_data_fill (row, &m_color_defaults, m_column_count);
return row;
167}

169// FIXMEchpe replace this with a method on BteRing
170BteRowData*
171Terminal::ring_append(bool fill)
172{
return ring_insert(_bte_ring_next(m_screen->row_data), fill);
174}

176// FIXMEchpe replace this with a method on BteRing
177void
178Terminal::ring_remove(bte::grid::row_t position)
179{
_bte_ring_remove(m_screen->row_data, position);
181}

183/* Reset defaults for character insertion. */
184void
185Terminal::reset_default_attributes(bool reset_hyperlink)
186{
      auto const hyperlink_idx_save = m_defaults.attr.hyperlink_idx;
      m_defaults = m_color_defaults = basic_cell;
      if (!reset_hyperlink)
              m_defaults.attr.hyperlink_idx = hyperlink_idx_save;
191}

193//FIXMEchpe this function is bad
194inline bte::view::coord_t
195Terminal::scroll_delta_pixel() const
196{
      return round(m_screen->scroll_delta * m_cell_height);
198}

200/*
* Terminal::pixel_to_row:
* @y: Y coordinate is relative to viewport, top padding excluded
*
* Returns: absolute row
*/
206inline bte::grid::row_t
207Terminal::pixel_to_row(bte::view::coord_t y) const
208{
      return (scroll_delta_pixel() + y) / m_cell_height;
210}

212/*
* Terminal::pixel_to_row:
* @row: absolute row
*
* Returns: Y coordinate relative to viewport with top padding excluded. If the row is
*   outside the viewport, may return any value < 0 or >= height
*/
219inline bte::view::coord_t
220Terminal::row_to_pixel(bte::grid::row_t row) const
221{
      // FIXMEchpe this is bad!
      return row * m_cell_height - (glong)round(m_screen->scroll_delta * m_cell_height);
224}

226inline bte::grid::row_t
227Terminal::first_displayed_row() const
228{
      return pixel_to_row(0);
230}

232inline bte::grid::row_t
233Terminal::last_displayed_row() const
234{
      /* Get the logical row number displayed at the bottom pixel position */
      auto r = pixel_to_row(m_view_usable_extents.height() - 1);

      /* If we have an extra padding at the bottom which is currently unused,
       * this number is one too big. Adjust here.
       * E.g. have a terminal of size 80 x 24.5.
       * Initially the bottom displayed row is (0-based) 23, but r is now 24.
       * After producing more than a screenful of content and scrolling back
       * all the way to the top, the bottom displayed row is (0-based) 24. */
      r = MIN (r, m_screen->insert_delta + m_row_count - 1)(((r) < (m_screen->insert_delta + m_row_count - 1)) ? (
r) : (m_screen->insert_delta + m_row_count - 1));
      return r;
246}

248/* Checks if the cursor is potentially at least partially onscreen.
* An outline cursor has an additional height of BTE_LINE_WIDTH pixels.
* It's also intentionally painted over the padding, up to BTE_LINE_WIDTH
* pixels under the real contents area. This method takes these into account.
* Only checks the cursor's row; not its visibility, shape, or offscreen column.
*/
254inline bool
255Terminal::cursor_is_onscreen() const noexcept
256{
      /* Note: the cursor can only be offscreen below the visible area, not above. */
      auto cursor_top = row_to_pixel (m_screen->cursor.row) - BTE_LINE_WIDTH1;
      auto display_bottom = m_view_usable_extents.height() + MIN(m_padding.bottom, BTE_LINE_WIDTH)(((m_padding.bottom) < (1)) ? (m_padding.bottom) : (1));
      return cursor_top < display_bottom;
261}

263/* Invalidate the requested rows. This is to be used when only the desired
* rendering changes but not the underlying data, e.g. moving or blinking
* cursor, highligthing with the mouse etc.
*
* Note that row_end is inclusive. This is not as nice as end-exclusive,
* but saves us from a +1 almost everywhere where this method is called.
*/
270void
271Terminal::invalidate_rows(bte::grid::row_t row_start,
                        bte::grid::row_t row_end /* inclusive */)
273{
if (G_UNLIKELY (!widget_realized())(__builtin_expect (__extension__ ({ int _g_boolean_var_946; if
 (!widget_realized()) _g_boolean_var_946 = 1; else _g_boolean_var_946
 = 0; _g_boolean_var_946; }), 0)))
              return;

      if (m_invalidated_all)
return;

      if (G_UNLIKELY (row_end < row_start)(__builtin_expect (__extension__ ({ int _g_boolean_var_947; if
 (row_end < row_start) _g_boolean_var_947 = 1; else _g_boolean_var_947
 = 0; _g_boolean_var_947; }), 0)))
              return;

_bte_debug_print (BTE_DEBUG_UPDATES,do { } while(0)
                        "Invalidating rows %ld..%ld.\n",do { } while(0)
                        row_start, row_end)do { } while(0);
_bte_debug_print (BTE_DEBUG_WORK, "?")do { } while(0);

      /* Scrolled back, visible parts didn't change. */
      if (row_start > last_displayed_row())
              return;

      /* Recognize if we're about to invalidate everything. */
      if (row_start <= first_displayed_row() &&
          row_end >= last_displayed_row()) {
invalidate_all();
return;
}

      cairo_rectangle_int_t rect;
/* Convert the column and row start and end to pixel values
* by multiplying by the size of a character cell.
* Always include the extra pixel border and overlap pixel.
*/
      // FIXMEegmont invalidate the left and right padding too
      rect.x = -1;
      int xend = m_column_count * m_cell_width + 1;
      rect.width = xend - rect.x;

      /* Always add at least BTE_LINE_WIDTH pixels so the outline block cursor fits */
      rect.y = row_to_pixel(row_start) - std::max(cell_overflow_top(), BTE_LINE_WIDTH1);
      int yend = row_to_pixel(row_end + 1) + std::max(cell_overflow_bottom(), BTE_LINE_WIDTH1);
      rect.height = yend - rect.y;

_bte_debug_print (BTE_DEBUG_UPDATES,do { } while(0)
	"Invalidating pixels at (%d,%d)x(%d,%d).\n",do { } while(0)
	rect.x, rect.y, rect.width, rect.height)do { } while(0);

if (m_active_terminals_link != nullptr) {
              g_array_append_val(m_update_rects, rect)g_array_append_vals (m_update_rects, &(rect), 1);
/* Wait a bit before doing any invalidation, just in
 * case updates are coming in really soon. */
add_update_timeout(this);
} else {
              auto allocation = get_allocated_rect();
              rect.x += allocation.x + m_padding.left;
              rect.y += allocation.y + m_padding.top;
              cairo_region_t *region = cairo_region_create_rectangle(&rect);
ctk_widget_queue_draw_region(m_widget, region);
              cairo_region_destroy(region);
}

_bte_debug_print (BTE_DEBUG_WORK, "!")do { } while(0);
333}

335/* Invalidate the requested rows, extending the region in both directions up to
* an explicit newline (or a safety limit) to invalidate entire paragraphs of text.
* This is to be used whenever the underlying data changes, because any such
* change might alter the desired BiDi, syntax highlighting etc. of all other
* rows of the involved paragraph(s).
*
* Note that row_end is inclusive. This is not as nice as end-exclusive,
* but saves us from a +1 almost everywhere where this method is called.
*/
344void
345Terminal::invalidate_rows_and_context(bte::grid::row_t row_start,
                                    bte::grid::row_t row_end /* inclusive */)
347{
      if (G_UNLIKELY (!widget_realized())(__builtin_expect (__extension__ ({ int _g_boolean_var_948; if
 (!widget_realized()) _g_boolean_var_948 = 1; else _g_boolean_var_948
 = 0; _g_boolean_var_948; }), 0)))
              return;

      if (m_invalidated_all)
              return;

      if (G_UNLIKELY (row_end < row_start)(__builtin_expect (__extension__ ({ int _g_boolean_var_949; if
 (row_end < row_start) _g_boolean_var_949 = 1; else _g_boolean_var_949
 = 0; _g_boolean_var_949; }), 0)))
              return;

      _bte_debug_print (BTE_DEBUG_UPDATES,do { } while(0)
                        "Invalidating rows %ld..%ld and context.\n",do { } while(0)
                        row_start, row_end)do { } while(0);

      /* Safety limit: Scrolled back by so much that changes to the
       * writable area may not affect the current viewport's rendering. */
      if (m_screen->insert_delta - BTE_RINGVIEW_PARAGRAPH_LENGTH_MAX500 > last_displayed_row())
              return;

      /* Extending the start is a bit tricky.
       * First extend it (towards lower numbered indices), but only up to
       * insert_delta - 1. Remember that the row at insert_delta - 1 is
       * still in the ring, hence checking its soft_wrapped flag is fast. */
      while (row_start >= m_screen->insert_delta) {
              if (!m_screen->row_data->is_soft_wrapped(row_start - 1))
                      break;
              row_start--;
      }

      /* If we haven't seen a newline yet, stop walking backwards row by row.
       * This is because we might need to access row_stream in order to check
       * the wrapped state, a way too expensive operation while processing
       * incoming data. Let displaying do extra work instead.
       * So just invalidate everything to the top. */
      if (row_start < m_screen->insert_delta) {
              row_start = first_displayed_row();
      }

      /* Extending the end is simple. Just walk until we go offscreen or
       * find an explicit newline. */
      while (row_end < last_displayed_row()) {
              if (!m_screen->row_data->is_soft_wrapped(row_end))
                      break;
              row_end++;
      }

      invalidate_rows(row_start, row_end);
394}

396/* Convenience methods */
397void
398Terminal::invalidate_row(bte::grid::row_t row)
399{
      invalidate_rows(row, row);
401}

403void
404Terminal::invalidate_row_and_context(bte::grid::row_t row)
405{
      invalidate_rows_and_context(row, row);
407}

409/* This is only used by the selection code, so no need to extend the area. */
410void
411Terminal::invalidate(bte::grid::span const& s)
412{
      if (!s.empty())
              invalidate_rows(s.start_row(), s.last_row());
415}

417/* Invalidates the symmetrical difference ("XOR" area) of the two spans.
* This is only used by the selection code, so no need to extend the area. */
419void
420Terminal::invalidate_symmetrical_difference(bte::grid::span const& a, bte::grid::span const& b, bool block)
421{
      if (a.empty() || b.empty() || a.start() >= b.end() || b.start() >= a.end()) {
              /* One or both are empty (invalidate() will figure out which), or disjoint intervals. */
              invalidate (a);
              invalidate (b);
              return;
      }

      if (block) {
              /* We could optimize when the columns don't change, probably not worth it. */
              invalidate_rows (std::min (a.start_row(), b.start_row()),
                               std::max (a.last_row(),  b.last_row()));
      } else {
              if (a.start() != b.start()) {
                      invalidate_rows (std::min (a.start_row(), b.start_row()),
                                       std::max (a.start_row(), b.start_row()));
              }
              if (a.end() != b.end()) {
                      invalidate_rows (std::min (a.last_row(), b.last_row()),
                                       std::max (a.last_row(), b.last_row()));
              }
      }
443}

445void
446Terminal::invalidate_all()
447{
if (G_UNLIKELY (!widget_realized())(__builtin_expect (__extension__ ({ int _g_boolean_var_950; if
 (!widget_realized()) _g_boolean_var_950 = 1; else _g_boolean_var_950
 = 0; _g_boolean_var_950; }), 0)))
              return;

if (m_invalidated_all) {
return;
}

_bte_debug_print (BTE_DEBUG_WORK, "*")do { } while(0);
_bte_debug_print (BTE_DEBUG_UPDATES, "Invalidating all.\n")do { } while(0);

/* replace invalid regions with one covering the whole terminal */
reset_update_rects();
m_invalidated_all = TRUE(!(0));

      if (m_active_terminals_link != nullptr) {
              auto allocation = get_allocated_rect();
              cairo_rectangle_int_t rect;
              rect.x = -m_padding.left;
              rect.y = -m_padding.top;
              rect.width = allocation.width;
              rect.height = allocation.height;

              g_array_append_val(m_update_rects, rect)g_array_append_vals (m_update_rects, &(rect), 1);
/* Wait a bit before doing any invalidation, just in
 * case updates are coming in really soon. */
add_update_timeout(this);
} else {
              ctk_widget_queue_draw(m_widget);
}
477}

479/* Find the row in the given position in the backscroll buffer.
* Note that calling this method may invalidate the return value of
* a previous find_row_data() call. */
482// FIXMEchpe replace this with a method on BteRing
483BteRowData const*
484Terminal::find_row_data(bte::grid::row_t row) const
485{
BteRowData const* rowdata = nullptr;

if (G_LIKELY(_bte_ring_contains(m_screen->row_data, row))(__builtin_expect (__extension__ ({ int _g_boolean_var_951; if
 (_bte_ring_contains(m_screen->row_data, row)) _g_boolean_var_951
 = 1; else _g_boolean_var_951 = 0; _g_boolean_var_951; }), 1)
)) {
rowdata = _bte_ring_index(m_screen->row_data, row);
}
return rowdata;
492}

494/* Find the row in the given position in the backscroll buffer. */
495// FIXMEchpe replace this with a method on BteRing
496BteRowData*
497Terminal::find_row_data_writable(bte::grid::row_t row) const
498{
BteRowData *rowdata = nullptr;

if (G_LIKELY (_bte_ring_contains(m_screen->row_data, row))(__builtin_expect (__extension__ ({ int _g_boolean_var_952; if
 (_bte_ring_contains(m_screen->row_data, row)) _g_boolean_var_952
 = 1; else _g_boolean_var_952 = 0; _g_boolean_var_952; }), 1)
)) {
rowdata = _bte_ring_index_writable(m_screen->row_data, row);
}
return rowdata;
505}

507/* Find the character an the given position in the backscroll buffer.
* Note that calling this method may invalidate the return value of
* a previous find_row_data() call. */
510// FIXMEchpe replace this with a method on BteRing
511BteCell const*
512Terminal::find_charcell(bte::grid::column_t col,
                                bte::grid::row_t row) const
514{
BteRowData const* rowdata;
BteCell const* ret = nullptr;

if (_bte_ring_contains(m_screen->row_data, row)) {
rowdata = _bte_ring_index(m_screen->row_data, row);
ret = _bte_row_data_get (rowdata, col);
}
return ret;
523}

525// FIXMEchpe replace this with a method on BteRing
526bte::grid::column_t
527Terminal::find_start_column(bte::grid::column_t col,
                                    bte::grid::row_t row) const
529{
BteRowData const* row_data = find_row_data(row);
if (G_UNLIKELY (col < 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_953; if
 (col < 0) _g_boolean_var_953 = 1; else _g_boolean_var_953
 = 0; _g_boolean_var_953; }), 0)))
return col;
if (row_data != nullptr) {
const BteCell *cell = _bte_row_data_get (row_data, col);
while (col > 0 && cell != NULL__null && cell->attr.fragment()) {
	cell = _bte_row_data_get (row_data, --col);
}
}
return MAX(col, 0)(((col) > (0)) ? (col) : (0));
540}

542// FIXMEchpe replace this with a method on BteRing
543bte::grid::column_t
544Terminal::find_end_column(bte::grid::column_t col,
                                  bte::grid::row_t row) const
546{
BteRowData const* row_data = find_row_data(row);
gint columns = 0;
if (G_UNLIKELY (col < 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_954; if
 (col < 0) _g_boolean_var_954 = 1; else _g_boolean_var_954
 = 0; _g_boolean_var_954; }), 0)))
return col;
if (row_data != NULL__null) {
const BteCell *cell = _bte_row_data_get (row_data, col);
while (col > 0 && cell != NULL__null && cell->attr.fragment()) {
	cell = _bte_row_data_get (row_data, --col);
}
if (cell) {
	columns = cell->attr.columns() - 1;
}
}
      // FIXMEchp m__column_count - 1 ?
return MIN(col + columns, m_column_count)(((col + columns) < (m_column_count)) ? (col + columns) : (
m_column_count));
562}

564/* Sets the line ending to hard wrapped (explicit newline).
* Takes care of invalidating if this operation splits a paragraph into two. */
566void
567Terminal::set_hard_wrapped(bte::grid::row_t row)
568{
      /* We can set the row just above insert_delta to hard wrapped. */
      g_assert_cmpint(row, >=, m_screen->insert_delta - 1)do { gint64 __n1 = (row), __n2 = (m_screen->insert_delta -
 1); if (__n1 >= __n2) ; else g_assertion_message_cmpnum (
"BTE", "../src/bte.cc", 570, ((const char*) (__PRETTY_FUNCTION__
)), "row" " " ">=" " " "m_screen->insert_delta - 1", (long
 double) __n1, ">=", (long double) __n2, 'i'); } while (0);
      g_assert_cmpint(row, <, m_screen->insert_delta + m_row_count)do { gint64 __n1 = (row), __n2 = (m_screen->insert_delta +
 m_row_count); if (__n1 < __n2) ; else g_assertion_message_cmpnum
 ("BTE", "../src/bte.cc", 571, ((const char*) (__PRETTY_FUNCTION__
)), "row" " " "<" " " "m_screen->insert_delta + m_row_count"
, (long double) __n1, "<", (long double) __n2, 'i'); } while
 (0);

      BteRowData *row_data = find_row_data_writable(row);

      /* It's okay for this row not to be covered by the ring. */
      if (row_data == nullptr || !row_data->attr.soft_wrapped)
              return;

      row_data->attr.soft_wrapped = false;

      m_ringview.invalidate();
      invalidate_rows_and_context(row, row + 1);
583}

585/* Sets the line ending to soft wrapped (overflow to the next line).
* Takes care of invalidating if this operation joins two paragraphs into one.
* Also makes sure that the joined new paragraph receives the first one's bidi flags. */
588void
589Terminal::set_soft_wrapped(bte::grid::row_t row)
590{
      g_assert_cmpint(row, >=, m_screen->insert_delta)do { gint64 __n1 = (row), __n2 = (m_screen->insert_delta);
 if (__n1 >= __n2) ; else g_assertion_message_cmpnum ("BTE"
, "../src/bte.cc", 591, ((const char*) (__PRETTY_FUNCTION__))
, "row" " " ">=" " " "m_screen->insert_delta", (long double
) __n1, ">=", (long double) __n2, 'i'); } while (0);
      g_assert_cmpint(row, <, m_screen->insert_delta + m_row_count)do { gint64 __n1 = (row), __n2 = (m_screen->insert_delta +
 m_row_count); if (__n1 < __n2) ; else g_assertion_message_cmpnum
 ("BTE", "../src/bte.cc", 592, ((const char*) (__PRETTY_FUNCTION__
)), "row" " " "<" " " "m_screen->insert_delta + m_row_count"
, (long double) __n1, "<", (long double) __n2, 'i'); } while
 (0);

      BteRowData *row_data = find_row_data_writable(row);
      g_assert(row_data != nullptr)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_955
; if (row_data != nullptr) _g_boolean_var_955 = 1; else _g_boolean_var_955
 = 0; _g_boolean_var_955; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 595, ((const char*) (__PRETTY_FUNCTION__
)), "row_data != nullptr"); } while (0);

      if (row_data->attr.soft_wrapped)
              return;

      row_data->attr.soft_wrapped = true;

      /* Each paragraph has to have consistent bidi flags across all of its rows.
       * Spread the first paragraph's flags across the second one (if they differ). */
      guint8 bidi_flags = row_data->attr.bidi_flags;
      bte::grid::row_t i = row + 1;
      row_data = find_row_data_writable(i);
      if (row_data != nullptr && row_data->attr.bidi_flags != bidi_flags) {
              do {
                      row_data->attr.bidi_flags = bidi_flags;
                      if (!row_data->attr.soft_wrapped)
                              break;
                      row_data = find_row_data_writable(++i);
              } while (row_data != nullptr);
      }

      m_ringview.invalidate();
      invalidate_rows_and_context(row, row + 1);
618}

620/* Determine the width of the portion of the preedit string which lies
* to the left of the cursor, or the entire string, in columns. */
622// FIXMEchpe this is for the view, so use int not gssize
623// FIXMEchpe this is only ever called with left_only=false, so remove the param
624gssize
625Terminal::get_preedit_width(bool left_only)
626{
gssize ret = 0;

      char const *preedit = m_im_preedit.c_str();
      for (int i = 0;
           // FIXMEchpe preddit is != NULL at the start, and next_char never returns NULL either
           (preedit != NULL__null) &&
     (preedit[0] != '\0') &&
     (!left_only || (i < m_im_preedit_cursor));
           i++) {
              gunichar c = g_utf8_get_char(preedit);
              ret += _bte_unichar_width(c, m_utf8_ambiguous_width);
              preedit = g_utf8_next_char(preedit)(char *)((preedit) + g_utf8_skip[*(const guchar *)(preedit)]);
      }

return ret;
642}

644/* Determine the length of the portion of the preedit string which lies
* to the left of the cursor, or the entire string, in gunichars. */
646// FIXMEchpe this returns gssize but inside it uses int...
647gssize
648Terminal::get_preedit_length(bool left_only)
649{
ssize_t i = 0;

      char const *preedit = m_im_preedit.c_str();
      for (i = 0;
           // FIXMEchpe useless check, see above
           (preedit != NULL__null) &&
     (preedit[0] != '\0') &&
     (!left_only || (i < m_im_preedit_cursor));
           i++) {
              preedit = g_utf8_next_char(preedit)(char *)((preedit) + g_utf8_skip[*(const guchar *)(preedit)]);
      }

return i;
663}

665void
666Terminal::invalidate_cursor_once(bool periodic)
667{
      if (G_UNLIKELY(!widget_realized())(__builtin_expect (__extension__ ({ int _g_boolean_var_956; if
 (!widget_realized()) _g_boolean_var_956 = 1; else _g_boolean_var_956
 = 0; _g_boolean_var_956; }), 0)))
              return;

if (m_invalidated_all) {
return;
}

if (periodic) {
if (!m_cursor_blinks) {
	return;
}
}

if (m_modes_private.DEC_TEXT_CURSOR()) {
              auto row = m_screen->cursor.row;

_bte_debug_print(BTE_DEBUG_UPDATES,do { } while(0)
                               "Invalidating cursor in row %ld.\n",do { } while(0)
                               row)do { } while(0);
              invalidate_row(row);
}
689}

691/* Invalidate the cursor repeatedly. */
692// FIXMEchpe this continually adds and removes the blink timeout. Find a better solution
693bool
694Terminal::cursor_blink_timer_callback()
695{
m_cursor_blink_state = !m_cursor_blink_state;
m_cursor_blink_time += m_cursor_blink_cycle;

invalidate_cursor_once(true);

/* only disable the blink if the cursor is currently shown.
* else, wait until next time.
*/
if (m_cursor_blink_time / 1000 >= m_cursor_blink_timeout &&
   m_cursor_blink_state) {
return false;
      }

      m_cursor_blink_timer.schedule(m_cursor_blink_cycle, bte::glib::Timer::Priority::eLOW);
      return false;
711}

713/* Emit a "selection_changed" signal. */
714void
715Terminal::emit_selection_changed()
716{
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Emitting `selection-changed'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_SELECTION_CHANGED], 0);
720}

722/* Emit a "commit" signal.
* FIXMEchpe: remove this function
*/
725void
726Terminal::emit_commit(std::string_view const& str)
727{
      if (str.size() == 0)
              return;

      if (!widget() || !widget()->should_emit_signal(SIGNAL_COMMIT))
              return;

_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                       "Emitting `commit' of %" G_GSSIZE_FORMAT" bytes.\n", str.size())do { } while(0);

      // FIXMEchpe we do know for a fact that all uses of this function
      // actually passed a 0-terminated string, so we can use @str directly
      std::string result{str}; // 0-terminated

      _BTE_DEBUG_IF(BTE_DEBUG_KEYBOARD)if (0) {
              for (size_t i = 0; i < result.size(); i++) {
                      if ((((guint8) result[i]) < 32) ||
                          (((guint8) result[i]) > 127)) {
                              g_printerr(
                                         "Sending <%02x> "
                                         "to child.\n",
                                         result[i]);
                      } else {
                              g_printerr(
                                         "Sending '%c' "
                                         "to child.\n",
                                         result[i]);
                      }
              }
      }

g_signal_emit(m_terminal, signals[SIGNAL_COMMIT], 0, result.c_str(), (guint)result.size());
759}

761void
762Terminal::queue_contents_changed()
763{
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Queueing `contents-changed'.\n")do { } while(0);
m_contents_changed_pending = true;
767}

769//FIXMEchpe this has only one caller
770void
771Terminal::queue_cursor_moved()
772{
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Queueing `cursor-moved'.\n")do { } while(0);
m_cursor_moved_pending = true;
776}

778void
779Terminal::emit_eof()
780{
      if (widget())
              widget()->emit_eof();
783}

785static gboolean
786emit_eof_idle_cb(BteTerminal *terminal)
787try
788{
      _bte_terminal_get_impl(terminal)->emit_eof();

      return G_SOURCE_REMOVE(0);
792}
793catch (...)
794{
      bte::log_exception();
      return G_SOURCE_REMOVE(0);
797}

799void
800Terminal::queue_eof()
801{
      _bte_debug_print(BTE_DEBUG_SIGNALS, "Queueing `eof'.\n")do { } while(0);

      g_idle_add_full(G_PRIORITY_HIGH-100,
                      (GSourceFunc)emit_eof_idle_cb,
                      g_object_ref(m_terminal),
                      g_object_unref);
808}

810void
811Terminal::emit_child_exited()
812{
      auto const status = m_child_exit_status;
      m_child_exit_status = -1;

      if (widget())
              widget()->emit_child_exited(status);
818}

820static gboolean
821emit_child_exited_idle_cb(BteTerminal *terminal)
822try
823{
      _bte_terminal_get_impl(terminal)->emit_child_exited();

      return G_SOURCE_REMOVE(0);
827}
828catch (...)
829{
      bte::log_exception();
      return G_SOURCE_REMOVE(0);
832}

834/* Emit a "child-exited" signal on idle, so that if the handler destroys
* the terminal, we're not deep within terminal code callstack
*/
837void
838Terminal::queue_child_exited()
839{
      _bte_debug_print(BTE_DEBUG_SIGNALS, "Queueing `child-exited'.\n")do { } while(0);
      m_child_exited_after_eos_pending = false;

      g_idle_add_full(G_PRIORITY_HIGH-100,
                      (GSourceFunc)emit_child_exited_idle_cb,
                      g_object_ref(m_terminal),
                      g_object_unref);
847}

849bool
850Terminal::child_exited_eos_wait_callback()
851{
      /* If we get this callback, there has been some time elapsed
       * after child-exited, but no EOS yet. This happens for example
       * when the primary child started other processes in the background,
       * which inherited the PTY, and thus keep it open, see
       * https://gitlab.gnome.org/GNOME/bte/issues/204
       *
       * Force an EOS.
       */
      if (pty())
              pty_io_read(pty()->fd(), G_IO_HUP);

      return false; // don't run again
864}

866/* Emit a "char-size-changed" signal. */
867void
868Terminal::emit_char_size_changed(int width,
                                         int height)
870{
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Emitting `char-size-changed'.\n")do { } while(0);
      /* FIXME on next API break, change the signature */
g_signal_emit(m_terminal, signals[SIGNAL_CHAR_SIZE_CHANGED], 0,
	      (guint)width, (guint)height);
876}

878/* Emit an "increase-font-size" signal. */
879void
880Terminal::emit_increase_font_size()
881{
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Emitting `increase-font-size'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_INCREASE_FONT_SIZE], 0);
885}

887/* Emit a "decrease-font-size" signal. */
888void
889Terminal::emit_decrease_font_size()
890{
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Emitting `decrease-font-size'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_DECREASE_FONT_SIZE], 0);
894}

896/* Emit a "text-inserted" signal. */
897void
898Terminal::emit_text_inserted()
899{
900#ifdef WITH_A11Y
if (!m_accessible_emit) {
return;
}
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Emitting `text-inserted'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_TEXT_INSERTED], 0);
907#endif
908}

910/* Emit a "text-deleted" signal. */
911void
912Terminal::emit_text_deleted()
913{
914#ifdef WITH_A11Y
if (!m_accessible_emit) {
return;
}
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Emitting `text-deleted'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_TEXT_DELETED], 0);
921#endif
922}

924/* Emit a "text-modified" signal. */
925void
926Terminal::emit_text_modified()
927{
928#ifdef WITH_A11Y
if (!m_accessible_emit) {
return;
}
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                       "Emitting `text-modified'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_TEXT_MODIFIED], 0);
935#endif
936}

938/* Emit a "text-scrolled" signal. */
939void
940Terminal::emit_text_scrolled(long delta)
941{
942#ifdef WITH_A11Y
if (!m_accessible_emit) {
return;
}
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
	"Emitting `text-scrolled'(%ld).\n", delta)do { } while(0);
      // FIXMEchpe fix signal signature?
g_signal_emit(m_terminal, signals[SIGNAL_TEXT_SCROLLED], 0, (int)delta);
950#endif
951}

953void
954Terminal::emit_copy_clipboard()
955{
_bte_debug_print(BTE_DEBUG_SIGNALS, "Emitting 'copy-clipboard'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_COPY_CLIPBOARD], 0);
958}

960void
961Terminal::emit_paste_clipboard()
962{
_bte_debug_print(BTE_DEBUG_SIGNALS, "Emitting 'paste-clipboard'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_PASTE_CLIPBOARD], 0);
965}

967/* Emit a "hyperlink_hover_uri_changed" signal. */
968void
969Terminal::emit_hyperlink_hover_uri_changed(const CdkRectangle *bbox)
970{
      GObject *object = G_OBJECT(m_terminal)((((GObject*) (void *) ((m_terminal)))));

      _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                       "Emitting `hyperlink-hover-uri-changed'.\n")do { } while(0);
      g_signal_emit(m_terminal, signals[SIGNAL_HYPERLINK_HOVER_URI_CHANGED], 0, m_hyperlink_hover_uri, bbox);
      g_object_notify_by_pspec(object, pspecs[PROP_HYPERLINK_HOVER_URI]);
977}

979void
980Terminal::deselect_all()
981{
      if (!m_selection_resolved.empty()) {
_bte_debug_print(BTE_DEBUG_SELECTION,do { } while(0)
		"Deselecting all text.\n")do { } while(0);

              m_selection_origin = m_selection_last = { -1, -1, 1 };
              resolve_selection();

/* Don't free the current selection, as we need to keep
 * hold of it for async copying from the clipboard. */

emit_selection_changed();
}
994}

996/* Clear the cache of the screen contents we keep. */
997void
998Terminal::match_contents_clear()
999{
match_hilite_clear();
if (m_match_contents != nullptr) {
g_free(m_match_contents);
m_match_contents = nullptr;
}
if (m_match_attributes != nullptr) {
g_array_free(m_match_attributes, TRUE(!(0)));
m_match_attributes = nullptr;
}
1009}

1011void
1012Terminal::match_contents_refresh()

1014{
match_contents_clear();
GArray *array = g_array_new(FALSE(0), TRUE(!(0)), sizeof(struct _BteCharAttributes));
      auto match_contents = get_text_displayed(true /* wrap */,
                                               array);
      m_match_contents = g_string_free(match_contents, FALSE(0));
m_match_attributes = array;
1021}

1023void
1024Terminal::regex_match_remove_all() noexcept
1025{
      auto& match_regexes = match_regexes_writable();
      match_regexes.clear();
      match_regexes.shrink_to_fit();

match_hilite_clear();
1031}

1033void
1034Terminal::regex_match_remove(int tag) noexcept
1035{
      auto i = regex_match_get_iter(tag);
      if (i == std::end(m_match_regexes))
              return;

      match_regexes_writable().erase(i);
1041}

1043/*
* match_rowcol_to_offset:
* @terminal:
* @column:
* @row:
* @offset_ptr: (out):
* @sattr_ptr: (out):
* @ettr_ptr: (out):
*
* Maps (row, column) to an offset in m_match_attributes, and returns
* that offset in @offset_ptr, and the start and end of the corresponding
* line in @sattr_ptr and @eattr_ptr.
*/
1056bool
1057Terminal::match_rowcol_to_offset(bte::grid::column_t column,
                                         bte::grid::row_t row,
                                         gsize *offset_ptr,
                                         gsize *sattr_ptr,
                                         gsize *eattr_ptr)
1062{
      /* FIXME: use gsize, after making sure the code below doesn't underflow offset */
      gssize offset, sattr, eattr;
      struct _BteCharAttributes *attr = NULL__null;

/* Map the pointer position to a portion of the string. */
      // FIXME do a bsearch here?
eattr = m_match_attributes->len;
for (offset = eattr; offset--; ) {
attr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(offset)])
		      struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(offset)])
		      offset)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(offset)]);
if (row < attr->row) {
	eattr = offset;
}
if (row == attr->row &&
    column >= attr->column && column < attr->column + attr->columns) {
	break;
}
}

_BTE_DEBUG_IF(BTE_DEBUG_REGEX)if (0) {
if (offset < 0)
	g_printerr("Cursor is not on a character.\n");
else {
                      gunichar c;
                      char utf[7];
                      c = g_utf8_get_char (m_match_contents + offset);
                      utf[g_unichar_to_utf8(g_unichar_isprint(c) ? c : 0xFFFD, utf)] = 0;

	g_printerr("Cursor is on character U+%04X '%s' at %" G_GSSIZE_FORMAT"li" ".\n",
                                 c, utf, offset);
              }
}

/* If the pointer isn't on a matchable character, bug out. */
if (offset < 0) {
return false;
}

/* If the pointer is on a newline, bug out. */
if (m_match_contents[offset] == '\0') {
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                               "Cursor is on newline.\n")do { } while(0);
return false;
}

/* Snip off any final newlines. */
while (m_match_contents[eattr] == '\n' ||
             m_match_contents[eattr] == '\0') {
eattr--;
}
/* and scan forwards to find the end of this line */
while (!(m_match_contents[eattr] == '\n' ||
               m_match_contents[eattr] == '\0')) {
eattr++;
}

/* find the start of row */
if (row == 0) {
sattr = 0;
} else {
for (sattr = offset; sattr > 0; sattr--) {
	attr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(sattr)])
			      struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(sattr)])
			      sattr)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(sattr)]);
	if (row > attr->row) {
		break;
	}
}
}
/* Scan backwards to find the start of this line */
while (sattr > 0 &&
! (m_match_contents[sattr] == '\n' ||
                 m_match_contents[sattr] == '\0')) {
sattr--;
}
/* and skip any initial newlines. */
while (m_match_contents[sattr] == '\n' ||
             m_match_contents[sattr] == '\0') {
sattr++;
}
if (eattr <= sattr) { /* blank line */
return false;
}
if (eattr <= offset || sattr > offset) {
/* nothing to match on this line */
return false;
}

      *offset_ptr = offset;
      *sattr_ptr = sattr;
      *eattr_ptr = eattr;

      _BTE_DEBUG_IF(BTE_DEBUG_REGEX)if (0) {
              struct _BteCharAttributes *_sattr, *_eattr;
              _sattr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(sattr)])
                                      struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(sattr)])
                                      sattr)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(sattr)]);
              _eattr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(eattr - 1)])
                                      struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(eattr - 1)])
                                      eattr - 1)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(eattr - 1)]);
              g_printerr("Cursor is in line from %" G_GSIZE_FORMAT"lu" "(%ld,%ld) to %" G_GSIZE_FORMAT"lu" "(%ld,%ld)\n",
                         sattr, _sattr->column, _sattr->row,
                         eattr - 1, _eattr->column, _eattr->row);
      }

      return true;
1170}

1172/* creates a pcre match context with appropriate limits */
1173pcre2_match_context_8 *
1174Terminal::create_match_context()
1175{
      pcre2_match_context_8 *match_context;

      match_context = pcre2_match_context_create_8(nullptr /* general context */);
      pcre2_set_match_limit_8(match_context, 65536); /* should be plenty */
      pcre2_set_recursion_limit_8(match_context, 64); /* should be plenty */

      return match_context;
1183}

1185bool
1186Terminal::match_check_pcre(pcre2_match_data_8 *match_data,
                         pcre2_match_context_8 *match_context,
                         bte::base::Regex const* regex,
                         uint32_t match_flags,
                         gsize sattr,
                         gsize eattr,
                         gsize offset,
                         char **result_ptr,
                         gsize *start,
                         gsize *end,
                         gsize *sblank_ptr,
                         gsize *eblank_ptr)
1198{
      int (* match_fn) (const pcre2_code_8 *,
                        PCRE2_SPTR8, PCRE2_SIZEsize_t, PCRE2_SIZEsize_t, uint32_t,
                        pcre2_match_data_8 *, pcre2_match_context_8 *);
      gsize sblank = 0, eblank = G_MAXSIZE(9223372036854775807L *2UL+1UL);
      gsize position, line_length;
      const char *line;
      int r = 0;

      if (regex->jited())
              match_fn = pcre2_jit_match_8;
      else
              match_fn = pcre2_match_8;

      line = m_match_contents;
      /* FIXME: what we really want is to pass the whole data to pcre2_match, but
       * limit matching to between sattr and eattr, so that the extra data can
       * satisfy lookahead assertions. This needs new pcre2 API though.
       */
      line_length = eattr;

      /* Iterate throught the matches until we either find one which contains the
       * offset, or we get no more matches.
       */
      pcre2_set_offset_limit_8(match_context, eattr);
      position = sattr;
      while (position < eattr &&
             ((r = match_fn(regex->code(),
                            (PCRE2_SPTR8)line, line_length, /* subject, length */
                            position, /* start offset */
                            match_flags |
                            PCRE2_NO_UTF_CHECK0x40000000u | PCRE2_NOTEMPTY0x00000004u | PCRE2_PARTIAL_SOFT0x00000010u /* FIXME: HARD? */,
                            match_data,
                            match_context)) >= 0 || r == PCRE2_ERROR_PARTIAL(-2))) {
              gsize ko = offset;
              gsize rm_so, rm_eo;
              gsize *ovector;

              ovector = pcre2_get_ovector_pointer_8(match_data);
              rm_so = ovector[0];
              rm_eo = ovector[1];
              if (G_UNLIKELY(rm_so == PCRE2_UNSET || rm_eo == PCRE2_UNSET)(__builtin_expect (__extension__ ({ int _g_boolean_var_957; if
 (rm_so == (~(size_t)0) || rm_eo == (~(size_t)0)) _g_boolean_var_957
 = 1; else _g_boolean_var_957 = 0; _g_boolean_var_957; }), 0)
))
                      break;

              /* The offsets should be "sane". We set NOTEMPTY, but check anyway */
              if (G_UNLIKELY(position == rm_eo)(__builtin_expect (__extension__ ({ int _g_boolean_var_958; if
 (position == rm_eo) _g_boolean_var_958 = 1; else _g_boolean_var_958
 = 0; _g_boolean_var_958; }), 0))) {
                      /* rm_eo is before the end of subject string's length, so this is safe */
                      position = g_utf8_next_char(line + rm_eo)(char *)((line + rm_eo) + g_utf8_skip[*(const guchar *)(line +
 rm_eo)]) - line;
                      continue;
              }

              _BTE_DEBUG_IF(BTE_DEBUG_REGEX)if (0) {
                      gchar *result;
                      struct _BteCharAttributes *_sattr, *_eattr;
                      result = g_strndup(line + rm_so, rm_eo - rm_so);
                      _sattr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(rm_so)])
                                              struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(rm_so)])
                                              rm_so)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(rm_so)]);
                      _eattr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(rm_eo - 1)])
                                              struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(rm_eo - 1)])
                                              rm_eo - 1)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(rm_eo - 1)]);
                      g_printerr("%s match `%s' from %" G_GSIZE_FORMAT"lu" "(%ld,%ld) to %" G_GSIZE_FORMAT"lu" "(%ld,%ld) (%" G_GSSIZE_FORMAT"li" ").\n",
                                 r == PCRE2_ERROR_PARTIAL(-2) ? "Partial":"Full",
                                 result,
                                 rm_so,
                                 _sattr->column,
                                 _sattr->row,
                                 rm_eo - 1,
                                 _eattr->column,
                                 _eattr->row,
                                 offset);
                      g_free(result);
              }

              /* advance position */
              position = rm_eo;

              /* FIXME: do handle newline / partial matches at end of line/start of next line */
              if (r == PCRE2_ERROR_PARTIAL(-2))
                      continue;

              /* If the pointer is in this substring, then we're done. */
              if (ko >= rm_so && ko < rm_eo) {
                      *result_ptr = g_strndup(line + rm_so, rm_eo - rm_so);
                      *start = rm_so;
                      *end = rm_eo - 1;
                      return true;
              }

              if (ko >= rm_eo && rm_eo > sblank) {
                      sblank = rm_eo;
              }
              if (ko < rm_so && rm_so < eblank) {
                      eblank = rm_so;
              }
      }

      if (G_UNLIKELY(r < PCRE2_ERROR_PARTIAL)(__builtin_expect (__extension__ ({ int _g_boolean_var_959; if
 (r < (-2)) _g_boolean_var_959 = 1; else _g_boolean_var_959
 = 0; _g_boolean_var_959; }), 0)))
              _bte_debug_print(BTE_DEBUG_REGEX, "Unexpected pcre2_match error code: %d\n", r)do { } while(0);

      *sblank_ptr = sblank;
      *eblank_ptr = eblank;
      return false;
1301}

1303char *
1304Terminal::match_check_internal_pcre(bte::grid::column_t column,
                                  bte::grid::row_t row,
                                  MatchRegex const** match,
                                  size_t* start,
                                  size_t* end)
1309{
gsize offset, sattr, eattr, start_blank, end_blank;
      pcre2_match_data_8 *match_data;
      pcre2_match_context_8 *match_context;

_bte_debug_print(BTE_DEBUG_REGEX,do { } while(0)
                       "Checking for pcre match at (%ld,%ld).\n", row, column)do { } while(0);

      if (!match_rowcol_to_offset(column, row,
                                  &offset, &sattr, &eattr))
              return nullptr;

start_blank = sattr;
end_blank = eattr;

      match_context = create_match_context();
      match_data = pcre2_match_data_create_8(256 /* should be plenty */, NULL__null /* general context */);

/* Now iterate over each regex we need to match against. */
      char* dingu_match{nullptr};
      for (auto const& rem : m_match_regexes) {
              gsize sblank, eblank;

              if (match_check_pcre(match_data, match_context,
                                   rem.regex(),
                                   rem.match_flags(),
                                   sattr, eattr, offset,
                                   &dingu_match,
                                   start, end,
                                   &sblank, &eblank)) {
                      _bte_debug_print(BTE_DEBUG_REGEX, "Matched dingu with tag %d\n", rem.tag())do { } while(0);
                      *match = std::addressof(rem);
                      break;
              }

              if (sblank > start_blank) {
                      start_blank = sblank;
              }
              if (eblank < end_blank) {
                      end_blank = eblank;
              }
}

      if (dingu_match == nullptr) {
              /* If we get here, there was no dingu match.
               * Record smallest span where none of the dingus match.
               */
              *start = start_blank;
              *end = end_blank - 1;
              *match = nullptr;

              _BTE_DEBUG_IF(BTE_DEBUG_REGEX)if (0) {
                      struct _BteCharAttributes *_sattr, *_eattr;
                      _sattr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(start_blank)])
                                              struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(start_blank)])
                                              start_blank)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(start_blank)]);
                      _eattr = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(end_blank - 1)])
                                              struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(end_blank - 1)])
                                              end_blank - 1)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(end_blank - 1)]);
                      g_printerr("No-match region from %" G_GSIZE_FORMAT"lu" "(%ld,%ld) to %" G_GSIZE_FORMAT"lu" "(%ld,%ld)\n",
                                 start_blank, _sattr->column, _sattr->row,
                                 end_blank - 1, _eattr->column, _eattr->row);
              }
      }

      pcre2_match_data_free_8(match_data);
      pcre2_match_context_free_8(match_context);

return dingu_match;
1378}

1380/*
* bte_terminal_match_check_internal:
* @terminal:
* @column:
* @row:
* @match: (out):
* @start: (out):
* @end: (out):
*
* Checks m_match_contents for dingu matches, and returns the start, and
* end of the match in @start, @end, and the matched regex in @match.
* If no match occurs, @match will be set to %nullptr,
* and if they are nonzero, @start and @end mark the smallest span in the @row
* in which none of the dingus match.
*
* Returns: (transfer full): the matched string, or %nullptr
*/
1397char *
1398Terminal::match_check_internal(bte::grid::column_t column,
                             bte::grid::row_t row,
                             MatchRegex const** match,
                             size_t* start,
                             size_t* end)
1403{
if (m_match_contents == nullptr) {
match_contents_refresh();
}

      assert(match != nullptr)(static_cast <bool> (match != nullptr) ? void (0) : __assert_fail
 ("match != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
      assert(start != nullptr)(static_cast <bool> (start != nullptr) ? void (0) : __assert_fail
 ("start != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
      assert(end != nullptr)(static_cast <bool> (end != nullptr) ? void (0) : __assert_fail
 ("end != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));

      *match = nullptr;
      *start = 0;
      *end = 0;

      return match_check_internal_pcre(column, row, match, start, end);
1417}

1419char*
1420Terminal::regex_match_check(bte::grid::column_t column,
                          bte::grid::row_t row,
                          int* tag)
1423{
long delta = m_screen->scroll_delta;
_bte_debug_print(BTE_DEBUG_EVENTS | BTE_DEBUG_REGEX,do { } while(0)
	"Checking for match at (%ld,%ld).\n",do { } while(0)
	row, column)do { } while(0);

      char* ret{nullptr};
      Terminal::MatchRegex const* match{nullptr};

      if (m_match_span.contains(row + delta, column)) {
              match = regex_match_current(); /* may be nullptr */
              ret = g_strdup(m_match)g_strdup_inline (m_match);
} else {
              gsize start, end;

              ret = match_check_internal(column, row + delta,
                                         &match,
                                         &start, &end);
}
_BTE_DEBUG_IF(BTE_DEBUG_EVENTS | BTE_DEBUG_REGEX)if (0) {
if (ret != NULL__null) g_printerr("Matched `%s'.\n", ret);
}
      if (tag != nullptr)
              *tag = (match != nullptr) ? match->tag() : -1;

return ret;
1449}

1451/*
* Terminal::view_coords_from_event:
* @event: a mouse event
*
* Translates the event coordinates to view coordinates, by
* subtracting the padding and window offset.
* Coordinates < 0 or >= m_usable_view_extents.width() or .height()
* mean that the event coordinates are outside the usable area
* at that side; use view_coords_visible() to check for that.
*/
1461bte::view::coords
1462Terminal::view_coords_from_event(MouseEvent const& event) const
1463{
      return bte::view::coords(event.x() - m_padding.left, event.y() - m_padding.top);
1465}

1467bool
1468Terminal::widget_realized() const noexcept
1469{
      return m_real_widget ? m_real_widget->realized() : false;
1471}

1473/*
* Terminal::grid_coords_from_event:
* @event: a mouse event
*
* Translates the event coordinates to view coordinates, by
* subtracting the padding and window offset.
* Coordinates < 0 or >= m_usable_view_extents.width() or .height()
* mean that the event coordinates are outside the usable area
* at that side; use grid_coords_visible() to check for that.
*/
1483bte::grid::coords
1484Terminal::grid_coords_from_event(MouseEvent const& event) const
1485{
      return grid_coords_from_view_coords(view_coords_from_event(event));
1487}

1489/*
* Terminal::confined_grid_coords_from_event:
* @event: a mouse event
*
* Like grid_coords_from_event(), but also confines the coordinates
* to an actual cell in the visible area.
*/
1496bte::grid::coords
1497Terminal::confined_grid_coords_from_event(MouseEvent const& event) const
1498{
      auto pos = view_coords_from_event(event);
      return confined_grid_coords_from_view_coords(pos);
1501}

1503/*
* Terminal::grid_coords_from_view_coords:
* @pos: the view coordinates
*
* Translates view coordinates to grid coordinates. If the view coordinates point to
* cells that are not visible, may return any value < 0 or >= m_column_count, and
* < first_displayed_row() or > last_displayed_row(), resp.
*/
1511bte::grid::coords
1512Terminal::grid_coords_from_view_coords(bte::view::coords const& pos) const
1513{
      /* Our caller had to update the ringview (we can't do because we're const). */
      g_assert(m_ringview.is_updated())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_960
; if (m_ringview.is_updated()) _g_boolean_var_960 = 1; else _g_boolean_var_960
 = 0; _g_boolean_var_960; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 1515, ((const char*) (__PRETTY_FUNCTION__
)), "m_ringview.is_updated()"); } while (0);

      bte::grid::column_t col;
      if (pos.x >= 0 && pos.x < m_view_usable_extents.width())
              col = pos.x / m_cell_width;
      else if (pos.x < 0)
              col = -1;
      else
              col = m_column_count;

      bte::grid::row_t row = pixel_to_row(pos.y);

      /* BiDi: convert to logical column. */
      bte::base::BidiRow const* bidirow = m_ringview.get_bidirow(confine_grid_row(row));
      col = bidirow->vis2log(col);

      return bte::grid::coords(row, col);
1532}

1534bte::grid::row_t
1535Terminal::confine_grid_row(bte::grid::row_t const& row) const
1536{
      auto first_row = first_displayed_row();
      auto last_row = last_displayed_row();

      return bte::clamp(row, first_row, last_row);
1541}

1543/*
* Terminal::confined_grid_coords_from_view_coords:
* @pos: the view coordinates
*
* Like grid_coords_from_view_coords(), but also confines the coordinates
* to an actual cell in the visible area.
*/
1550bte::grid::coords
1551Terminal::confined_grid_coords_from_view_coords(bte::view::coords const& pos) const
1552{
      auto rowcol = grid_coords_from_view_coords(pos);
      return confine_grid_coords(rowcol);
1555}

1557/*
* Terminal::view_coords_from_grid_coords:
* @rowcol: the grid coordinates
*
* Translates grid coordinates to view coordinates. If the view coordinates are
* outside the usable area, may return any value < 0 or >= m_usable_view_extents.
*
* Returns: %true if the coordinates are inside the usable area
*/
1566bte::view::coords
1567Terminal::view_coords_from_grid_coords(bte::grid::coords const& rowcol) const
1568{
      return bte::view::coords(rowcol.column() * m_cell_width,
                               row_to_pixel(rowcol.row()));
1571}

1573bool
1574Terminal::view_coords_visible(bte::view::coords const& pos) const
1575{
      return pos.x >= 0 && pos.x < m_view_usable_extents.width() &&
             pos.y >= 0 && pos.y < m_view_usable_extents.height();
1578}

1580bool
1581Terminal::grid_coords_visible(bte::grid::coords const& rowcol) const
1582{
      return rowcol.column() >= 0 &&
             rowcol.column() < m_column_count &&
             rowcol.row() >= first_displayed_row() &&
             rowcol.row() <= last_displayed_row();
1587}

1589bte::grid::coords
1590Terminal::confine_grid_coords(bte::grid::coords const& rowcol) const
1591{
      /* Confine clicks to the nearest actual cell. This is especially useful for
       * fullscreen bte so that you can click on the very edge of the screen.
       */
      auto first_row = first_displayed_row();
      auto last_row = last_displayed_row();

      return bte::grid::coords(CLAMP(rowcol.row(), first_row, last_row)(((rowcol.row()) > (last_row)) ? (last_row) : (((rowcol.row
()) < (first_row)) ? (first_row) : (rowcol.row()))),
                               CLAMP(rowcol.column(), 0, m_column_count - 1)(((rowcol.column()) > (m_column_count - 1)) ? (m_column_count
 - 1) : (((rowcol.column()) < (0)) ? (0) : (rowcol.column(
)))));
1600}

1602/*
* Track mouse click and drag positions (the "origin" and "last" coordinates) with half cell accuracy,
* that is, know whether the event occurred over the left/start or right/end half of the cell.
* This is required because some selection modes care about the cell over which the event occurred,
* while some care about the closest boundary between cells.
*
* Storing the actual view coordinates would become problematic when the font size changes (bug 756058),
* and would cause too much work when the mouse moves within the half cell.
*
* Left/start margin or anything further to the left/start is denoted by column -1's right half,
* right/end margin or anything further to the right/end is denoted by column m_column_count's left half.
*
* BiDi: returns logical position (start or end) for normal selection modes, visual position (left or
* right) for block mode.
*/
1617bte::grid::halfcoords
1618Terminal::selection_grid_halfcoords_from_view_coords(bte::view::coords const& pos) const
1619{
      /* Our caller had to update the ringview (we can't do because we're const). */
      g_assert(m_ringview.is_updated())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_961
; if (m_ringview.is_updated()) _g_boolean_var_961 = 1; else _g_boolean_var_961
 = 0; _g_boolean_var_961; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 1621, ((const char*) (__PRETTY_FUNCTION__
)), "m_ringview.is_updated()"); } while (0);

      bte::grid::row_t row = pixel_to_row(pos.y);
      bte::grid::column_t col;
      bte::grid::half_t half;

      if (pos.x < 0) {
              col = -1;
              half = 1;
      } else if (pos.x >= m_column_count * m_cell_width) {
              col = m_column_count;
              half = 0;
      } else {
              col = pos.x / m_cell_width;
              half = (pos.x * 2 / m_cell_width) % 2;
      }

      if (!m_selection_block_mode) {
              /* BiDi: convert from visual to logical half column. */
              bte::base::BidiRow const* bidirow = m_ringview.get_bidirow(confine_grid_row(row));

              if (bidirow->vis_is_rtl(col))
                      half = 1 - half;
              col = bidirow->vis2log(col);
      }

      return { row, bte::grid::halfcolumn_t(col, half) };
1648}

1650/*
* Called on Shift+Click to continue (extend or shrink) the previous selection.
* Swaps the two endpoints of the selection if needed, so that m_selection_origin
* contains the new fixed point and m_selection_last is the newly dragged end.
* In block mode it might even switch to the other two corners.
* As per CTK+'s generic selection behavior, retains the origin and last
* endpoints if the Shift+click happened inside the selection.
*/
1658void
1659Terminal::selection_maybe_swap_endpoints(bte::view::coords const& pos)
1660{
      if (m_selection_resolved.empty())
              return;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto current = selection_grid_halfcoords_from_view_coords (pos);

      if (m_selection_block_mode) {
              if ((current.row() <= m_selection_origin.row() && m_selection_origin.row() < m_selection_last.row()) ||
                  (current.row() >= m_selection_origin.row() && m_selection_origin.row() > m_selection_last.row())) {
                      // FIXME see if we can use std::swap()
                      auto tmp = m_selection_origin.row();
                      m_selection_origin.set_row(m_selection_last.row());
                      m_selection_last.set_row(tmp);
              }
              if ((current.halfcolumn() <= m_selection_origin.halfcolumn() && m_selection_origin.halfcolumn() < m_selection_last.halfcolumn()) ||
                  (current.halfcolumn() >= m_selection_origin.halfcolumn() && m_selection_origin.halfcolumn() > m_selection_last.halfcolumn())) {
                      // FIXME see if we can use std::swap()
                      auto tmp = m_selection_origin.halfcolumn();
                      m_selection_origin.set_halfcolumn(m_selection_last.halfcolumn());
                      m_selection_last.set_halfcolumn(tmp);
              }
      } else {
              if ((current <= m_selection_origin && m_selection_origin < m_selection_last) ||
                  (current >= m_selection_origin && m_selection_origin > m_selection_last)) {
                      std::swap (m_selection_origin, m_selection_last);
              }
      }

      _bte_debug_print(BTE_DEBUG_SELECTION,do { } while(0)
                       "Selection maybe swap endpoints: origin=%s last=%s\n",do { } while(0)
                       m_selection_origin.to_string(),do { } while(0)
                       m_selection_last.to_string())do { } while(0);
1695}

1697bool
1698Terminal::rowcol_from_event(MouseEvent const& event,
                          long *column,
                          long *row)
1701{
      auto rowcol = grid_coords_from_event(event);
      if (!grid_coords_visible(rowcol))
              return false;

      *column = rowcol.column();
      *row = rowcol.row();
      return true;
1709}

1711char *
1712Terminal::hyperlink_check(MouseEvent const& event)
1713{
      long col, row;
      const char *hyperlink;
      const char *separator;

      if (!m_allow_hyperlink)
              return NULL__null;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      if (!rowcol_from_event(event, &col, &row))
              return NULL__null;

      _bte_ring_get_hyperlink_at_position(m_screen->row_data, row, col, false, &hyperlink);

      if (hyperlink != NULL__null) {
              /* URI is after the first semicolon */
              separator = strchr(hyperlink, ';');
              g_assert(separator != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_962
; if (separator != __null) _g_boolean_var_962 = 1; else _g_boolean_var_962
 = 0; _g_boolean_var_962; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 1732, ((const char*) (__PRETTY_FUNCTION__
)), "separator != NULL"); } while (0);
              hyperlink = separator + 1;
      }

      _bte_debug_print (BTE_DEBUG_HYPERLINK,do { } while(0)
                        "hyperlink_check: \"%s\"\n",do { } while(0)
                        hyperlink)do { } while(0);

      return g_strdup(hyperlink)g_strdup_inline (hyperlink);
1741}

1743char *
1744Terminal::regex_match_check(MouseEvent const& event,
                          int *tag)
1746{
      long col, row;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      if (!rowcol_from_event(event, &col, &row))
              return FALSE(0);

      /* FIXME Shouldn't rely on a deprecated, not sub-row aware method. */
      // FIXMEchpe fix this scroll_delta substraction!
      return regex_match_check(col, row - (long)m_screen->scroll_delta, tag);
1758}

1760bool
1761Terminal::regex_match_check_extra(MouseEvent const& event,
                                bte::base::Regex const** regexes,
                                size_t n_regexes,
                                uint32_t match_flags,
                                char** matches)
1766{
gsize offset, sattr, eattr;
      pcre2_match_data_8 *match_data;
      pcre2_match_context_8 *match_context;
      bool any_matches = false;
      long col, row;
      guint i;

      assert(regexes != nullptr || n_regexes == 0)(static_cast <bool> (regexes != nullptr || n_regexes ==
 0) ? void (0) : __assert_fail ("regexes != nullptr || n_regexes == 0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      assert(matches != nullptr)(static_cast <bool> (matches != nullptr) ? void (0) : __assert_fail
 ("matches != nullptr", __builtin_FILE (), __builtin_LINE (),
 __extension__ __PRETTY_FUNCTION__));

      /* Need to ensure the ringview is updated. */
      ringview_update();

      if (!rowcol_from_event(event, &col, &row))
              return false;

if (m_match_contents == nullptr) {
match_contents_refresh();
}

      if (!match_rowcol_to_offset(col, row,
                                  &offset, &sattr, &eattr))
              return false;

      match_context = create_match_context();
      match_data = pcre2_match_data_create_8(256 /* should be plenty */, nullptr /* general context */);

      for (i = 0; i < n_regexes; i++) {
              gsize start, end, sblank, eblank;
              char *match_string;

              g_return_val_if_fail(regexes[i] != nullptr, false)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_963
; if (regexes[i] != nullptr) _g_boolean_var_963 = 1; else _g_boolean_var_963
 = 0; _g_boolean_var_963; }), 1))) { } else { g_return_if_fail_warning
 ("BTE", ((const char*) (__PRETTY_FUNCTION__)), "regexes[i] != nullptr"
); return (false); } } while (0);

              if (match_check_pcre(match_data, match_context,
                                   regexes[i], match_flags,
                                   sattr, eattr, offset,
                                   &match_string,
                                   &start, &end,
                                   &sblank, &eblank)) {
                      _bte_debug_print(BTE_DEBUG_REGEX, "Matched regex with text: %s\n", match_string)do { } while(0);
                      matches[i] = match_string;
                      any_matches = true;
              } else
                      matches[i] = nullptr;
      }

      pcre2_match_data_free_8(match_data);
      pcre2_match_context_free_8(match_context);

      return any_matches;
1817}

1819/* Emit an adjustment changed signal on our adjustment object. */
1820void
1821Terminal::emit_adjustment_changed()
1822{
if (m_adjustment_changed_pending) {
bool changed = false;
gdouble current, v;

              auto vadjustment = m_vadjustment.get();

              auto const freezer = bte::glib::FreezeObjectNotify{vadjustment};

v = _bte_ring_delta (m_screen->row_data);
              current = ctk_adjustment_get_lower(vadjustment);
if (!_bte_double_equal(current, v)) {
	_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
			"Changing lower bound from %.0f to %f\n",do { } while(0)
			 current, v)do { } while(0);
                      ctk_adjustment_set_lower(vadjustment, v);
	changed = true;
}

v = m_screen->insert_delta + m_row_count;
              current = ctk_adjustment_get_upper(vadjustment);
if (!_bte_double_equal(current, v)) {
	_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
			"Changing upper bound from %.0f to %f\n",do { } while(0)
			 current, v)do { } while(0);
                      ctk_adjustment_set_upper(vadjustment, v);
	changed = true;
}

/* The step increment should always be one. */
              v = ctk_adjustment_get_step_increment(vadjustment);
if (!_bte_double_equal(v, 1)) {
	_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
			"Changing step increment from %.0lf to 1\n", v)do { } while(0);
                      ctk_adjustment_set_step_increment(vadjustment, 1);
	changed = true;
}

/* Set the number of rows the user sees to the number of rows the
 * user sees. */
              v = ctk_adjustment_get_page_size(vadjustment);
if (!_bte_double_equal(v, m_row_count)) {
	_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
			"Changing page size from %.0f to %ld\n",do { } while(0)
			 v, m_row_count)do { } while(0);
                      ctk_adjustment_set_page_size(vadjustment,
				     m_row_count);
	changed = true;
}

/* Clicking in the empty area should scroll one screen, so set the
 * page size to the number of visible rows. */
              v = ctk_adjustment_get_page_increment(vadjustment);
if (!_bte_double_equal(v, m_row_count)) {
	_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
			"Changing page increment from "do { } while(0)
			"%.0f to %ld\n",do { } while(0)
			v, m_row_count)do { } while(0);
                      ctk_adjustment_set_page_increment(vadjustment,
					  m_row_count);
	changed = true;
}

if (changed)
	_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
			"Emitting adjustment_changed.\n")do { } while(0);
m_adjustment_changed_pending = FALSE(0);
}
if (m_adjustment_value_changed_pending) {
double v, delta;
_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
		"Emitting adjustment_value_changed.\n")do { } while(0);
m_adjustment_value_changed_pending = FALSE(0);

              auto vadjustment = m_vadjustment.get();
              v = ctk_adjustment_get_value(vadjustment);
if (!_bte_double_equal(v, m_screen->scroll_delta)) {
	/* this little dance is so that the scroll_delta is
	 * updated immediately, but we still handled scrolling
	 * via the adjustment - e.g. user interaction with the
	 * scrollbar
	 */
	delta = m_screen->scroll_delta;
	m_screen->scroll_delta = v;
                      ctk_adjustment_set_value(vadjustment, delta);
}
}
1909}

1911/* Queue an adjustment-changed signal to be delivered when convenient. */
1912// FIXMEchpe this has just one caller, fold it into the call site
1913void
1914Terminal::queue_adjustment_changed()
1915{
m_adjustment_changed_pending = true;
add_update_timeout(this);
1918}

1920void
1921Terminal::queue_adjustment_value_changed(double v)
1922{
if (!_bte_double_equal(v, m_screen->scroll_delta)) {
              _bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
                               "Adjustment value changed to %f\n",do { } while(0)
                               v)do { } while(0);
m_screen->scroll_delta = v;
m_adjustment_value_changed_pending = true;
add_update_timeout(this);
}
1931}

1933void
1934Terminal::queue_adjustment_value_changed_clamped(double v)
1935{
      auto vadjustment = m_vadjustment.get();
      auto const lower = ctk_adjustment_get_lower(vadjustment);
      auto const upper = ctk_adjustment_get_upper(vadjustment);

v = CLAMP(v, lower, MAX (lower, upper - m_row_count))(((v) > ((((lower) > (upper - m_row_count)) ? (lower) :
 (upper - m_row_count)))) ? ((((lower) > (upper - m_row_count
)) ? (lower) : (upper - m_row_count))) : (((v) < (lower)) ?
 (lower) : (v)));

queue_adjustment_value_changed(v);
1943}

1945void
1946Terminal::adjust_adjustments()
1947{
g_assert(m_screen != nullptr)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_964
; if (m_screen != nullptr) _g_boolean_var_964 = 1; else _g_boolean_var_964
 = 0; _g_boolean_var_964; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 1948, ((const char*) (__PRETTY_FUNCTION__
)), "m_screen != nullptr"); } while (0);
g_assert(m_screen->row_data != nullptr)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_965
; if (m_screen->row_data != nullptr) _g_boolean_var_965 = 1
; else _g_boolean_var_965 = 0; _g_boolean_var_965; }), 1)) ; else
 g_assertion_message_expr ("BTE", "../src/bte.cc", 1949, ((const
 char*) (__PRETTY_FUNCTION__)), "m_screen->row_data != nullptr"
); } while (0);

queue_adjustment_changed();

/* The lower value should be the first row in the buffer. */
long delta = _bte_ring_delta(m_screen->row_data);
/* Snap the insert delta and the cursor position to be in the visible
* area.  Leave the scrolling delta alone because it will be updated
* when the adjustment changes. */
m_screen->insert_delta = MAX(m_screen->insert_delta, delta)(((m_screen->insert_delta) > (delta)) ? (m_screen->insert_delta
) : (delta));
      m_screen->cursor.row = MAX(m_screen->cursor.row,(((m_screen->cursor.row) > (m_screen->insert_delta))
 ? (m_screen->cursor.row) : (m_screen->insert_delta))
                                 m_screen->insert_delta)(((m_screen->cursor.row) > (m_screen->insert_delta))
 ? (m_screen->cursor.row) : (m_screen->insert_delta));

if (m_screen->scroll_delta > m_screen->insert_delta) {
queue_adjustment_value_changed(m_screen->insert_delta);
}
1965}

1967/* Update the adjustment field of the widget.  This function should be called
* whenever we add rows to or remove rows from the history or switch screens. */
1969void
1970Terminal::adjust_adjustments_full()
1971{
g_assert(m_screen != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_966
; if (m_screen != __null) _g_boolean_var_966 = 1; else _g_boolean_var_966
 = 0; _g_boolean_var_966; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 1972, ((const char*) (__PRETTY_FUNCTION__
)), "m_screen != NULL"); } while (0);
g_assert(m_screen->row_data != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_967
; if (m_screen->row_data != __null) _g_boolean_var_967 = 1
; else _g_boolean_var_967 = 0; _g_boolean_var_967; }), 1)) ; else
 g_assertion_message_expr ("BTE", "../src/bte.cc", 1973, ((const
 char*) (__PRETTY_FUNCTION__)), "m_screen->row_data != NULL"
); } while (0);

adjust_adjustments();
queue_adjustment_changed();
1977}

1979/* Scroll a fixed number of lines up or down in the current screen. */
1980void
1981Terminal::scroll_lines(long lines)
1982{
double destination;
_bte_debug_print(BTE_DEBUG_ADJ, "Scrolling %ld lines.\n", lines)do { } while(0);
/* Calculate the ideal position where we want to be before clamping. */
destination = m_screen->scroll_delta;
      /* Snap to whole cell offset. */
      if (lines > 0)
              destination = floor(destination);
      else if (lines < 0)
              destination = ceil(destination);
destination += lines;
/* Tell the scrollbar to adjust itself. */
queue_adjustment_value_changed_clamped(destination);
1995}

1997/* Scroll so that the scroll delta is the minimum value. */
1998void
1999Terminal::maybe_scroll_to_top()
2000{
queue_adjustment_value_changed(_bte_ring_delta(m_screen->row_data));
2002}

2004void
2005Terminal::maybe_scroll_to_bottom()
2006{
queue_adjustment_value_changed(m_screen->insert_delta);
_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
	"Snapping to bottom of screen\n")do { } while(0);
2010}

2012/*
* Terminal::set_encoding:
* @charset: (allow-none): target charset, or %NULL to use UTF-8
*
* Changes the encoding the terminal will expect data from the child to
* be encoded with.  If @charset is %NULL, it uses "UTF-8".
*
* Returns: %true if the encoding could be changed to the specified one
*/
2021bool
2022Terminal::set_encoding(char const* charset,
                     GError** error)
2024{
2025#ifdef WITH_ICU
      auto const to_utf8 = bool{charset == nullptr || g_ascii_strcasecmp(charset, "UTF-8") == 0};

      if (to_utf8) {
              if (data_syntax() == DataSyntax::eECMA48_UTF8)
                      return true;

              m_converter.reset();
              m_data_syntax = DataSyntax::eECMA48_UTF8;
      } else {
              if (data_syntax() == DataSyntax::eECMA48_PCTERM &&
                  m_converter->charset() == charset)
                      return true;

              auto converter = bte::base::ICUConverter::make(charset, error);
              if (!converter)
                      return false;

              m_converter = std::move(converter);
              m_data_syntax = DataSyntax::eECMA48_PCTERM;
      }

      /* Note: we DON'T convert any pending output from the previous charset to
       * the new charset, since that is in general not possible without loss, and
       * also the output may include binary data (Terminal::feed_child_binary()).
       * So we just clear the outgoing queue. (FIXMEchpe: instead, we could flush
       * the outgooing and only change charsets once it's empty.)
       * Do not clear the incoming queue.
       */
      _bte_byte_array_clear(m_outgoing)g_byte_array_set_size (m_outgoing, 0);

      reset_decoder();

      if (pty())
              pty()->set_utf8(data_syntax() == DataSyntax::eECMA48_UTF8);

_bte_debug_print(BTE_DEBUG_IO,do { } while(0)
                       "Set terminal encoding to `%s'.\n",do { } while(0)
                       encoding())do { } while(0);

      return true;
2066#else
      g_set_error_literal(error, G_CONVERT_ERRORg_convert_error_quark(), G_CONVERT_ERROR_NO_CONVERSION,
                          "ICU support not available");
      return false;
2070#endif
2071}

2073bool
2074Terminal::set_cjk_ambiguous_width(int width)
2075{
      g_assert(width == 1 || width == 2)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_968
; if (width == 1 || width == 2) _g_boolean_var_968 = 1; else _g_boolean_var_968
 = 0; _g_boolean_var_968; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 2076, ((const char*) (__PRETTY_FUNCTION__
)), "width == 1 || width == 2"); } while (0);

      if (m_utf8_ambiguous_width == width)
              return false;

      m_utf8_ambiguous_width = width;
      return true;
2083}

2085// FIXMEchpe replace this with a method on BteRing
2086BteRowData *
2087Terminal::insert_rows (guint cnt)
2088{
BteRowData *row;
do {
row = ring_append(false);
} while(--cnt);
return row;
2094}

2096/* Make sure we have enough rows and columns to hold data at the current
* cursor position. */
2098BteRowData *
2099Terminal::ensure_row()
2100{
BteRowData *row;

/* Figure out how many rows we need to add. */
auto const delta = m_screen->cursor.row - _bte_ring_next(m_screen->row_data) + 1;
if (delta > 0) {
row = insert_rows(delta);
adjust_adjustments();
} else {
/* Find the row the cursor is in. */
row = _bte_ring_index_writable(m_screen->row_data, m_screen->cursor.row);
}
g_assert(row != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_969
; if (row != __null) _g_boolean_var_969 = 1; else _g_boolean_var_969
 = 0; _g_boolean_var_969; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 2112, ((const char*) (__PRETTY_FUNCTION__
)), "row != NULL"); } while (0);

return row;
2115}

2117BteRowData *
2118Terminal::ensure_cursor()
2119{
BteRowData *row = ensure_row();
      _bte_row_data_fill(row, &basic_cell, m_screen->cursor.col);

return row;
2124}

2126/* Update the insert delta so that the screen which includes it also
* includes the end of the buffer. */
2128void
2129Terminal::update_insert_delta()
2130{
/* The total number of lines.  Add one to the cursor offset
* because it's zero-based. */
auto rows = _bte_ring_next(m_screen->row_data);
      auto delta = m_screen->cursor.row - rows + 1;
if (G_UNLIKELY (delta > 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_970; if
 (delta > 0) _g_boolean_var_970 = 1; else _g_boolean_var_970
 = 0; _g_boolean_var_970; }), 0))) {
insert_rows(delta);
rows = _bte_ring_next(m_screen->row_data);
}

/* Make sure that the bottom row is visible, and that it's in
* the buffer (even if it's empty).  This usually causes the
* top row to become a history-only row. */
delta = m_screen->insert_delta;
delta = MIN(delta, rows - m_row_count)(((delta) < (rows - m_row_count)) ? (delta) : (rows - m_row_count
));
delta = MAX(delta,(((delta) > (m_screen->cursor.row - (m_row_count - 1)))
 ? (delta) : (m_screen->cursor.row - (m_row_count - 1)))
                  m_screen->cursor.row - (m_row_count - 1))(((delta) > (m_screen->cursor.row - (m_row_count - 1)))
 ? (delta) : (m_screen->cursor.row - (m_row_count - 1)));
delta = MAX(delta, _bte_ring_delta(m_screen->row_data))(((delta) > (_bte_ring_delta(m_screen->row_data))) ? (delta
) : (_bte_ring_delta(m_screen->row_data)));

/* Adjust the insert delta and scroll if needed. */
if (delta != m_screen->insert_delta) {
m_screen->insert_delta = delta;
adjust_adjustments();
}
2154}

2156/* Apply the desired mouse pointer, based on certain member variables. */
2157void
2158Terminal::apply_mouse_cursor()
2159{
      if (!widget_realized())
              return;

      /* Show the cursor if over the widget and not autohidden, this is obvious.
       * Also show the cursor if outside the widget regardless of the autohidden state, so that if a popover is opened
       * and then the cursor returns (which doesn't trigger enter/motion events), it is visible.
       * That is, only hide the cursor if it's over the widget and is autohidden.
       * See bug 789390 and bug 789536 comment 6 for details. */
      if (!(m_mouse_autohide && m_mouse_cursor_autohidden && m_mouse_cursor_over_widget)) {
              if (m_hyperlink_hover_idx != 0) {
                      _bte_debug_print(BTE_DEBUG_CURSOR,do { } while(0)
                                      "Setting hyperlink mouse cursor.\n")do { } while(0);
                      m_real_widget->set_cursor(bte::platform::Widget::CursorType::eHyperlink);
              } else if (regex_match_has_current()) {
                      m_real_widget->set_cursor(regex_match_current()->cursor());
              } else if (m_mouse_tracking_mode != MouseTrackingMode::eNONE) {
	_bte_debug_print(BTE_DEBUG_CURSOR,do { } while(0)
			"Setting mousing cursor.\n")do { } while(0);
                      m_real_widget->set_cursor(bte::platform::Widget::CursorType::eMousing);
} else {
	_bte_debug_print(BTE_DEBUG_CURSOR,do { } while(0)
			"Setting default mouse cursor.\n")do { } while(0);
                      m_real_widget->set_cursor(bte::platform::Widget::CursorType::eDefault);
}
} else {
_bte_debug_print(BTE_DEBUG_CURSOR,do { } while(0)
		"Setting to invisible cursor.\n")do { } while(0);
              m_real_widget->set_cursor(bte::platform::Widget::CursorType::eInvisible);
}
2189}

2191/* Show or hide the pointer if autohiding is enabled. */
2192void
2193Terminal::set_pointer_autohidden(bool autohidden)
2194{
      if (autohidden == m_mouse_cursor_autohidden)
              return;

      m_mouse_cursor_autohidden = autohidden;

      if (m_mouse_autohide) {
              hyperlink_hilite_update();
              match_hilite_update();
              apply_mouse_cursor();
      }
2205}

2207/*
* Get the actually used color from the palette.
* The return value can be NULL only if entry is one of BTE_CURSOR_BG,
* BTE_CURSOR_FG, BTE_HIGHLIGHT_BG or BTE_HIGHLIGHT_FG.
*/
2212bte::color::rgb const*
2213Terminal::get_color(int entry) const
2214{
BtePaletteColor const* palette_color = &m_palette[entry];
guint source;
for (source = 0; source < G_N_ELEMENTS(palette_color->sources)(sizeof (palette_color->sources) / sizeof ((palette_color->
sources)[0])); source++)
if (palette_color->sources[source].is_set)
	return &palette_color->sources[source].color;
return nullptr;
2221}

2223/* Set up a palette entry with a more-or-less match for the requested color. */
2224void
2225Terminal::set_color(int entry,
                            int source,
                            bte::color::rgb const& proposed)
2228{
      g_assert(entry >= 0 && entry < BTE_PALETTE_SIZE)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_971
; if (entry >= 0 && entry < 263) _g_boolean_var_971
 = 1; else _g_boolean_var_971 = 0; _g_boolean_var_971; }), 1)
) ; else g_assertion_message_expr ("BTE", "../src/bte.cc", 2229
, ((const char*) (__PRETTY_FUNCTION__)), "entry >= 0 && entry < BTE_PALETTE_SIZE"
); } while (0);

BtePaletteColor *palette_color = &m_palette[entry];

      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color[%d] to (%04x,%04x,%04x).\n",do { } while(0)
                       source == BTE_COLOR_SOURCE_ESCAPE ? "escape" : "API",do { } while(0)
                       entry, proposed.red, proposed.green, proposed.blue)do { } while(0);

      if (palette_color->sources[source].is_set &&
          palette_color->sources[source].color == proposed) {
              return;
      }
      palette_color->sources[source].is_set = TRUE(!(0));
      palette_color->sources[source].color = proposed;

/* If we're not realized yet, there's nothing else to do. */
if (!widget_realized())
return;

/* and redraw */
if (entry == BTE_CURSOR_BG261 || entry == BTE_CURSOR_FG262)
invalidate_cursor_once();
else
invalidate_all();
2254}

2256void
2257Terminal::reset_color(int entry,
                              int source)
2259{
      g_assert(entry >= 0 && entry < BTE_PALETTE_SIZE)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_972
; if (entry >= 0 && entry < 263) _g_boolean_var_972
 = 1; else _g_boolean_var_972 = 0; _g_boolean_var_972; }), 1)
) ; else g_assertion_message_expr ("BTE", "../src/bte.cc", 2260
, ((const char*) (__PRETTY_FUNCTION__)), "entry >= 0 && entry < BTE_PALETTE_SIZE"
); } while (0);

BtePaletteColor *palette_color = &m_palette[entry];

      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Reset %s color[%d].\n",do { } while(0)
                       source == BTE_COLOR_SOURCE_ESCAPE ? "escape" : "API",do { } while(0)
                       entry)do { } while(0);

      if (!palette_color->sources[source].is_set) {
              return;
      }
      palette_color->sources[source].is_set = FALSE(0);

/* If we're not realized yet, there's nothing else to do. */
if (!widget_realized())
return;

/* and redraw */
if (entry == BTE_CURSOR_BG261 || entry == BTE_CURSOR_FG262)
invalidate_cursor_once();
else
invalidate_all();
2283}

2285bool
2286Terminal::set_background_alpha(double alpha)
2287{
      g_assert(alpha >= 0. && alpha <= 1.)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_973
; if (alpha >= 0. && alpha <= 1.) _g_boolean_var_973
 = 1; else _g_boolean_var_973 = 0; _g_boolean_var_973; }), 1)
) ; else g_assertion_message_expr ("BTE", "../src/bte.cc", 2288
, ((const char*) (__PRETTY_FUNCTION__)), "alpha >= 0. && alpha <= 1."
); } while (0);

      if (_bte_double_equal(alpha, m_background_alpha))
              return false;

      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Setting background alpha to %.3f\n", alpha)do { } while(0);
      m_background_alpha = alpha;

      invalidate_all();

      return true;
2300}

2302void
2303Terminal::set_colors_default()
2304{
      set_colors(nullptr, nullptr, nullptr, 0);
2306}

2308/*
* Terminal::set_colors:
* @terminal: a #BteTerminal
* @foreground: (allow-none): the new foreground color, or %NULL
* @background: (allow-none): the new background color, or %NULL
* @palette: (array length=palette_size zero-terminated=0): the color palette
* @palette_size: the number of entries in @palette
*
* @palette specifies the new values for the 256 palette colors: 8 standard colors,
* their 8 bright counterparts, 6x6x6 color cube, and 24 grayscale colors.
* Omitted entries will default to a hardcoded value.
*
* @palette_size must be 0, 8, 16, 232 or 256.
*
* If @foreground is %NULL and @palette_size is greater than 0, the new foreground
* color is taken from @palette[7].  If @background is %NULL and @palette_size is
* greater than 0, the new background color is taken from @palette[0].
*/
2326void
2327Terminal::set_colors(bte::color::rgb const* foreground,
                             bte::color::rgb const* background,
                             bte::color::rgb const* new_palette,
                             gsize palette_size)
2331{
_bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
	"Set color palette [%" G_GSIZE_FORMAT " elements].\n",do { } while(0)
	palette_size)do { } while(0);

/* Accept NULL as the default foreground and background colors if we
* got a palette. */
if ((foreground == NULL__null) && (palette_size >= 8)) {
foreground = &new_palette[7];
}
if ((background == NULL__null) && (palette_size >= 8)) {
background = &new_palette[0];
}

/* Initialize each item in the palette if we got any entries to work
* with. */
for (gsize i = 0; i < G_N_ELEMENTS(m_palette)(sizeof (m_palette) / sizeof ((m_palette)[0])); i++) {
              bte::color::rgb color;
bool unset = false;

if (i < 16) {
	color.blue = (i & 4) ? 0xc000 : 0;
	color.green = (i & 2) ? 0xc000 : 0;
	color.red = (i & 1) ? 0xc000 : 0;
	if (i > 7) {
		color.blue += 0x3fff;
		color.green += 0x3fff;
		color.red += 0x3fff;
	}
}
else if (i < 232) {
	int j = i - 16;
	int r = j / 36, g = (j / 6) % 6, b = j % 6;
	int red =   (r == 0) ? 0 : r * 40 + 55;
	int green = (g == 0) ? 0 : g * 40 + 55;
	int blue =  (b == 0) ? 0 : b * 40 + 55;
	color.red   = red | red << 8  ;
	color.green = green | green << 8;
	color.blue  = blue | blue << 8;
} else if (i < 256) {
	int shade = 8 + (i - 232) * 10;
	color.red = color.green = color.blue = shade | shade << 8;
}
else switch (i) {
	case BTE_DEFAULT_BG257:
		if (background) {
			color = *background;
		} else {
			color.red = 0;
			color.blue = 0;
			color.green = 0;
		}
		break;
	case BTE_DEFAULT_FG256:
		if (foreground) {
			color = *foreground;
		} else {
			color.red = 0xc000;
			color.blue = 0xc000;
			color.green = 0xc000;
		}
		break;
	case BTE_BOLD_FG258:
                              unset = true;
                              break;
	case BTE_HIGHLIGHT_BG260:
		unset = true;
		break;
	case BTE_HIGHLIGHT_FG259:
		unset = true;
		break;
	case BTE_CURSOR_BG261:
		unset = true;
		break;
	case BTE_CURSOR_FG262:
		unset = true;
		break;
	}

/* Override from the supplied palette if there is one. */
if (i < palette_size) {
	color = new_palette[i];
}

/* Set up the color entry. */
              if (unset)
                      reset_color(i, BTE_COLOR_SOURCE_API1);
              else
                      set_color(i, BTE_COLOR_SOURCE_API1, color);
}
2421}

2423/*
* Terminal::set_color_bold:
* @bold: (allow-none): the new bold color or %NULL
*
* Sets the color used to draw bold text in the default foreground color.
* If @bold is %NULL then the default color is used.
*/
2430void
2431Terminal::set_color_bold(bte::color::rgb const& color)
2432{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color to (%04x,%04x,%04x).\n", "bold",do { } while(0)
                       color.red, color.green, color.blue)do { } while(0);
      set_color(BTE_BOLD_FG258, BTE_COLOR_SOURCE_API1, color);
2437}

2439void
2440Terminal::reset_color_bold()
2441{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Reset %s color.\n", "bold")do { } while(0);
      reset_color(BTE_BOLD_FG258, BTE_COLOR_SOURCE_API1);
2445}

2447/*
* Terminal::set_color_foreground:
* @foreground: the new foreground color
*
* Sets the foreground color used to draw normal text.
*/
2453void
2454Terminal::set_color_foreground(bte::color::rgb const& color)
2455{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color to (%04x,%04x,%04x).\n", "foreground",do { } while(0)
                       color.red, color.green, color.blue)do { } while(0);
set_color(BTE_DEFAULT_FG256, BTE_COLOR_SOURCE_API1, color);
2460}

2462/*
* Terminal::set_color_background:
* @background: the new background color
*
* Sets the background color for text which does not have a specific background
* color assigned.  Only has effect when no background image is set and when
* the terminal is not transparent.
*/
2470void
2471Terminal::set_color_background(bte::color::rgb const& color)
2472{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color to (%04x,%04x,%04x).\n", "background",do { } while(0)
                       color.red, color.green, color.blue)do { } while(0);
set_color(BTE_DEFAULT_BG257, BTE_COLOR_SOURCE_API1, color);
2477}

2479/*
* Terminal::set_color_cursor_background:
* @cursor_background: (allow-none): the new color to use for the text cursor, or %NULL
*
* Sets the background color for text which is under the cursor.  If %NULL, text
* under the cursor will be drawn with foreground and background colors
* reversed.
*/
2487void
2488Terminal::set_color_cursor_background(bte::color::rgb const& color)
2489{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color to (%04x,%04x,%04x).\n", "cursor background",do { } while(0)
                       color.red, color.green, color.blue)do { } while(0);
set_color(BTE_CURSOR_BG261, BTE_COLOR_SOURCE_API1, color);
2494}

2496void
2497Terminal::reset_color_cursor_background()
2498{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Reset %s color.\n", "cursor background")do { } while(0);
      reset_color(BTE_CURSOR_BG261, BTE_COLOR_SOURCE_API1);
2502}

2504/*
* Terminal::set_color_cursor_foreground:
* @cursor_foreground: (allow-none): the new color to use for the text cursor, or %NULL
*
* Sets the foreground color for text which is under the cursor.  If %NULL, text
* under the cursor will be drawn with foreground and background colors
* reversed.
*/
2512void
2513Terminal::set_color_cursor_foreground(bte::color::rgb const& color)
2514{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color to (%04x,%04x,%04x).\n", "cursor foreground",do { } while(0)
                       color.red, color.green, color.blue)do { } while(0);
set_color(BTE_CURSOR_FG262, BTE_COLOR_SOURCE_API1, color);
2519}

2521void
2522Terminal::reset_color_cursor_foreground()
2523{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Reset %s color.\n", "cursor foreground")do { } while(0);
      reset_color(BTE_CURSOR_FG262, BTE_COLOR_SOURCE_API1);
2527}

2529/*
* Terminal::set_color_highlight_background:
* @highlight_background: (allow-none): the new color to use for highlighted text, or %NULL
*
* Sets the background color for text which is highlighted.  If %NULL,
* it is unset.  If neither highlight background nor highlight foreground are set,
* highlighted text (which is usually highlighted because it is selected) will
* be drawn with foreground and background colors reversed.
*/
2538void
2539Terminal::set_color_highlight_background(bte::color::rgb const& color)
2540{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color to (%04x,%04x,%04x).\n", "highlight background",do { } while(0)
                       color.red, color.green, color.blue)do { } while(0);
set_color(BTE_HIGHLIGHT_BG260, BTE_COLOR_SOURCE_API1, color);
2545}

2547void
2548Terminal::reset_color_highlight_background()
2549{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Reset %s color.\n", "highlight background")do { } while(0);
      reset_color(BTE_HIGHLIGHT_BG260, BTE_COLOR_SOURCE_API1);
2553}

2555/*
* Terminal::set_color_highlight_foreground:
* @highlight_foreground: (allow-none): the new color to use for highlighted text, or %NULL
*
* Sets the foreground color for text which is highlighted.  If %NULL,
* it is unset.  If neither highlight background nor highlight foreground are set,
* highlighted text (which is usually highlighted because it is selected) will
* be drawn with foreground and background colors reversed.
*/
2564void
2565Terminal::set_color_highlight_foreground(bte::color::rgb const& color)
2566{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Set %s color to (%04x,%04x,%04x).\n", "highlight foreground",do { } while(0)
                       color.red, color.green, color.blue)do { } while(0);
set_color(BTE_HIGHLIGHT_FG259, BTE_COLOR_SOURCE_API1, color);
2571}

2573void
2574Terminal::reset_color_highlight_foreground()
2575{
      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                       "Reset %s color.\n", "highlight foreground")do { } while(0);
      reset_color(BTE_HIGHLIGHT_FG259, BTE_COLOR_SOURCE_API1);
2579}

2581/*
* Terminal::cleanup_fragments:
* @start: the starting column, inclusive
* @end: the end column, exclusive
*
* Needs to be called before modifying the contents in the cursor's row,
* between the two given columns.  Cleans up TAB and CJK fragments to the
* left of @start and to the right of @end.  If a CJK is split in half,
* the remaining half is replaced by a space.  If a TAB at @start is split,
* it is replaced by spaces.  If a TAB at @end is split, it is replaced by
* a shorter TAB.  @start and @end can be equal if characters will be
* inserted at the location rather than overwritten.
*
* The area between @start and @end is not cleaned up, hence the whole row
* can be left in an inconsistent state.  It is expected that the caller
* will fill up that range afterwards, resulting in a consistent row again.
*
* Invalidates the cells that visually change outside of the range,
* because the caller can't reasonably be expected to take care of this.
*/
2601void
2602Terminal::cleanup_fragments(long start,
                                    long end)
2604{
      BteRowData *row = ensure_row();
      const BteCell *cell_start;
      BteCell *cell_end, *cell_col;
      gboolean cell_start_is_fragment;
      long col;

      g_assert(end >= start)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_974
; if (end >= start) _g_boolean_var_974 = 1; else _g_boolean_var_974
 = 0; _g_boolean_var_974; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 2611, ((const char*) (__PRETTY_FUNCTION__
)), "end >= start"); } while (0);

      /* Remember whether the cell at start is a fragment.  We'll need to know it when
       * handling the left hand side, but handling the right hand side first might
       * overwrite it if start == end (inserting to the middle of a character). */
      cell_start = _bte_row_data_get (row, start);
      cell_start_is_fragment = cell_start != NULL__null && cell_start->attr.fragment();

      /* On the right hand side, try to replace a TAB by a shorter TAB if we can.
       * This requires that the TAB on the left (which might be the same TAB) is
       * not yet converted to spaces, so start on the right hand side. */
      cell_end = _bte_row_data_get_writable (row, end);
      if (G_UNLIKELY (cell_end != NULL && cell_end->attr.fragment())(__builtin_expect (__extension__ ({ int _g_boolean_var_975; if
 (cell_end != __null && cell_end->attr.fragment())
 _g_boolean_var_975 = 1; else _g_boolean_var_975 = 0; _g_boolean_var_975
; }), 0))) {
              col = end;
              do {
                      col--;
                      g_assert(col >= 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_976
; if (col >= 0) _g_boolean_var_976 = 1; else _g_boolean_var_976
 = 0; _g_boolean_var_976; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 2627, ((const char*) (__PRETTY_FUNCTION__
)), "col >= 0"); } while (0);  /* The first cell can't be a fragment. */
                      cell_col = _bte_row_data_get_writable (row, col);
              } while (cell_col->attr.fragment());
              if (cell_col->c == '\t') {
                      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                                       "Replacing right part of TAB with a shorter one at %ld (%ld cells) => %ld (%ld cells)\n",do { } while(0)
                                       col, (long) cell_col->attr.columns(), end, (long) cell_col->attr.columns() - (end - col))do { } while(0);
                      cell_end->c = '\t';
                      cell_end->attr.set_fragment(false);
                      g_assert(cell_col->attr.columns() > end - col)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_977
; if (cell_col->attr.columns() > end - col) _g_boolean_var_977
 = 1; else _g_boolean_var_977 = 0; _g_boolean_var_977; }), 1)
) ; else g_assertion_message_expr ("BTE", "../src/bte.cc", 2636
, ((const char*) (__PRETTY_FUNCTION__)), "cell_col->attr.columns() > end - col"
); } while (0);
                      cell_end->attr.set_columns(cell_col->attr.columns() - (end - col));
              } else {
                      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                                       "Cleaning CJK right half at %ld\n",do { } while(0)
                                       end)do { } while(0);
                      g_assert(end - col == 1 && cell_col->attr.columns() == 2)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_978
; if (end - col == 1 && cell_col->attr.columns() ==
 2) _g_boolean_var_978 = 1; else _g_boolean_var_978 = 0; _g_boolean_var_978
; }), 1)) ; else g_assertion_message_expr ("BTE", "../src/bte.cc"
, 2642, ((const char*) (__PRETTY_FUNCTION__)), "end - col == 1 && cell_col->attr.columns() == 2"
); } while (0);
                      cell_end->c = ' ';
                      cell_end->attr.set_fragment(false);
                      cell_end->attr.set_columns(1);
                      invalidate_row_and_context(m_screen->cursor.row);  /* FIXME can we do cheaper? */
              }
      }

      /* Handle the left hand side.  Converting longer TABs to shorter ones probably
       * wouldn't make that much sense here, so instead convert to spaces. */
      if (G_UNLIKELY (cell_start_is_fragment)(__builtin_expect (__extension__ ({ int _g_boolean_var_979; if
 (cell_start_is_fragment) _g_boolean_var_979 = 1; else _g_boolean_var_979
 = 0; _g_boolean_var_979; }), 0))) {
              gboolean keep_going = TRUE(!(0));
              col = start;
              do {
                      col--;
                      g_assert(col >= 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_980
; if (col >= 0) _g_boolean_var_980 = 1; else _g_boolean_var_980
 = 0; _g_boolean_var_980; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 2657, ((const char*) (__PRETTY_FUNCTION__
)), "col >= 0"); } while (0);  /* The first cell can't be a fragment. */
                      cell_col = _bte_row_data_get_writable (row, col);
                      if (!cell_col->attr.fragment()) {
                              if (cell_col->c == '\t') {
                                      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                                                       "Replacing left part of TAB with spaces at %ld (%ld => %ld cells)\n",do { } while(0)
                                                       col, (long)cell_col->attr.columns(), start - col)do { } while(0);
                                      /* nothing to do here */
                              } else {
                                      _bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
                                                       "Cleaning CJK left half at %ld\n",do { } while(0)
                                                       col)do { } while(0);
                                      g_assert(start - col == 1)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_981
; if (start - col == 1) _g_boolean_var_981 = 1; else _g_boolean_var_981
 = 0; _g_boolean_var_981; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 2669, ((const char*) (__PRETTY_FUNCTION__
)), "start - col == 1"); } while (0);
                                      invalidate_row_and_context(m_screen->cursor.row);  /* FIXME can we do cheaper? */
                              }
                              keep_going = FALSE(0);
                      }
                      cell_col->c = ' ';
                      cell_col->attr.set_fragment(false);
                      cell_col->attr.set_columns(1);
              } while (keep_going);
      }
2679}

2681/* Cursor down, with scrolling. */
2682void
2683Terminal::cursor_down(bool explicit_sequence)
2684{
long start, end;

      if (m_scrolling_restricted) {
              start = m_screen->insert_delta + m_scrolling_region.start;
              end = m_screen->insert_delta + m_scrolling_region.end;
} else {
start = m_screen->insert_delta;
end = start + m_row_count - 1;
}
      if (m_screen->cursor.row == end) {
              if (m_scrolling_restricted) {
	if (start == m_screen->insert_delta) {
                              /* Set the boundary to hard wrapped where
                               * we're about to tear apart the contents. */
                              set_hard_wrapped(m_screen->cursor.row);
		/* Scroll this line into the scrollback
		 * buffer by inserting a line at the next
		 * line and scrolling the area up. */
		m_screen->insert_delta++;
                              m_screen->cursor.row++;
                              /* Update start and end, too. */
		start++;
		end++;
                              ring_insert(m_screen->cursor.row, false);
                              /* Repaint the affected lines, which is _below_
                               * the region (bug 131). No need to extend,
                               * set_hard_wrapped() took care of invalidating
                               * the context lines if necessary. */
                              invalidate_rows(m_screen->cursor.row,
                                              m_screen->insert_delta + m_row_count - 1);
		/* Force scroll. */
		adjust_adjustments();
	} else {
                              /* Set the boundaries to hard wrapped where
                               * we're about to tear apart the contents. */
                              set_hard_wrapped(start - 1);
                              set_hard_wrapped(end);
                              /* Scroll by removing a line and inserting a new one. */
		ring_remove(start);
		ring_insert(end, true);
                              /* Repaint the affected lines. No need to extend,
                               * set_hard_wrapped() took care of invalidating
                               * the context lines if necessary. */
                              invalidate_rows(start, end);
	}
} else {
	/* Scroll up with history. */
                      m_screen->cursor.row++;
	update_insert_delta();
}

              /* Handle bce (background color erase), however, diverge from xterm:
               * only fill the new row with the background color if scrolling
               * happens due to an explicit escape sequence, not due to autowrapping.
               * See bug 754596 for details. */
              bool const not_default_bg = (m_color_defaults.attr.back() != BTE_DEFAULT_BG257);

              if (explicit_sequence && not_default_bg) {
	BteRowData *rowdata = ensure_row();
                      _bte_row_data_fill (rowdata, &m_color_defaults, m_column_count);
}
      } else if (m_screen->cursor.row < m_screen->insert_delta + m_row_count - 1) {
              /* Otherwise, just move the cursor down; unless it's already in the last
               * physical row (which is possible with scrolling region, see #176). */
              m_screen->cursor.row++;
}
2751}

2753/* Drop the scrollback. */
2754void
2755Terminal::drop_scrollback()
2756{
      /* Only for normal screen; alternate screen doesn't have a scrollback. */
      _bte_ring_drop_scrollback (m_normal_screen.row_data,
                                 m_normal_screen.insert_delta);

      if (m_screen == &m_normal_screen) {
              queue_adjustment_value_changed(m_normal_screen.insert_delta);
              adjust_adjustments_full();
      }
2765}

2767/* Restore cursor on a screen. */
2768void
2769Terminal::restore_cursor(BteScreen *screen__)
2770{
      screen__->cursor.col = screen__->saved.cursor.col;
      screen__->cursor.row = screen__->insert_delta + CLAMP(screen__->saved.cursor.row,(((screen__->saved.cursor.row) > (m_row_count - 1)) ? (
m_row_count - 1) : (((screen__->saved.cursor.row) < (0)
) ? (0) : (screen__->saved.cursor.row)))
                                                            0, m_row_count - 1)(((screen__->saved.cursor.row) > (m_row_count - 1)) ? (
m_row_count - 1) : (((screen__->saved.cursor.row) < (0)
) ? (0) : (screen__->saved.cursor.row)));

      m_modes_ecma.set_modes(screen__->saved.modes_ecma);

      m_modes_private.set_DEC_REVERSE_IMAGE(screen__->saved.reverse_mode);
      m_modes_private.set_DEC_ORIGIN(screen__->saved.origin_mode);

      m_defaults = screen__->saved.defaults;
      m_color_defaults = screen__->saved.color_defaults;
      m_character_replacements[0] = screen__->saved.character_replacements[0];
      m_character_replacements[1] = screen__->saved.character_replacements[1];
      m_character_replacement = screen__->saved.character_replacement;
2785}

2787/* Save cursor on a screen__. */
2788void
2789Terminal::save_cursor(BteScreen *screen__)
2790{
      screen__->saved.cursor.col = screen__->cursor.col;
      screen__->saved.cursor.row = screen__->cursor.row - screen__->insert_delta;

      screen__->saved.modes_ecma = m_modes_ecma.get_modes();

      screen__->saved.reverse_mode = m_modes_private.DEC_REVERSE_IMAGE();
      screen__->saved.origin_mode = m_modes_private.DEC_ORIGIN();

      screen__->saved.defaults = m_defaults;
      screen__->saved.color_defaults = m_color_defaults;
      screen__->saved.character_replacements[0] = m_character_replacements[0];
      screen__->saved.character_replacements[1] = m_character_replacements[1];
      screen__->saved.character_replacement = m_character_replacement;
2804}

2806/* Insert a single character into the stored data array. */
2807void
2808Terminal::insert_char(gunichar c,
                              bool insert,
                              bool invalidate_now)
2811{
BteCellAttr attr;
BteRowData *row;
long col;
int columns, i;
bool line_wrapped = false; /* cursor moved before char inserted */
      gunichar c_unmapped = c;

      /* DEC Special Character and Line Drawing Set.  VT100 and higher (per XTerm docs). */
      static const gunichar line_drawing_map[32] = {
              0x0020,  /* _ => blank (space) */
              0x25c6,  /* ` => diamond */
              0x2592,  /* a => checkerboard */
              0x2409,  /* b => HT symbol */
              0x240c,  /* c => FF symbol */
              0x240d,  /* d => CR symbol */
              0x240a,  /* e => LF symbol */
              0x00b0,  /* f => degree */
              0x00b1,  /* g => plus/minus */
              0x2424,  /* h => NL symbol */
              0x240b,  /* i => VT symbol */
              0x2518,  /* j => downright corner */
              0x2510,  /* k => upright corner */
              0x250c,  /* l => upleft corner */
              0x2514,  /* m => downleft corner */
              0x253c,  /* n => cross */
              0x23ba,  /* o => scan line 1/9 */
              0x23bb,  /* p => scan line 3/9 */
              0x2500,  /* q => horizontal line (also scan line 5/9) */
              0x23bc,  /* r => scan line 7/9 */
              0x23bd,  /* s => scan line 9/9 */
              0x251c,  /* t => left t */
              0x2524,  /* u => right t */
              0x2534,  /* v => bottom t */
              0x252c,  /* w => top t */
              0x2502,  /* x => vertical line */
              0x2264,  /* y => <= */
              0x2265,  /* z => >= */
              0x03c0,  /* { => pi */
              0x2260,  /* | => not equal */
              0x00a3,  /* } => pound currency sign */
              0x00b7,  /* ~ => bullet */
      };

      insert |= m_modes_ecma.IRM();

/* If we've enabled the special drawing set, map the characters to
* Unicode. */
      if (G_UNLIKELY (*m_character_replacement == BTE_CHARACTER_REPLACEMENT_LINE_DRAWING)(__builtin_expect (__extension__ ({ int _g_boolean_var_982; if
 (*m_character_replacement == BTE_CHARACTER_REPLACEMENT_LINE_DRAWING
) _g_boolean_var_982 = 1; else _g_boolean_var_982 = 0; _g_boolean_var_982
; }), 0))) {
              if (c >= 95 && c <= 126)
                      c = line_drawing_map[c - 95];
      }

/* Figure out how many columns this character should occupy. */
      columns = _bte_unichar_width(c, m_utf8_ambiguous_width);

/* If we're autowrapping here, do it. */
      col = m_screen->cursor.col;
if (G_UNLIKELY (columns && col + columns > m_column_count)(__builtin_expect (__extension__ ({ int _g_boolean_var_983; if
 (columns && col + columns > m_column_count) _g_boolean_var_983
 = 1; else _g_boolean_var_983 = 0; _g_boolean_var_983; }), 0)
)) {
if (m_modes_private.DEC_AUTOWRAP()) {
	_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
			"Autowrapping before character\n")do { } while(0);
	/* Wrap. */
	/* XXX clear to the end of line */
                      col = m_screen->cursor.col = 0;
	/* Mark this line as soft-wrapped. */
	row = ensure_row();
                      set_soft_wrapped(m_screen->cursor.row);
                      cursor_down(false);
                      ensure_row();
                      apply_bidi_attributes(m_screen->cursor.row, row->attr.bidi_flags, BTE_BIDI_FLAG_ALL);
} else {
	/* Don't wrap, stay at the rightmost column. */
                      col = m_screen->cursor.col =
		m_column_count - columns;
}
line_wrapped = true;
}

_bte_debug_print(BTE_DEBUG_PARSER,do { } while(0)
	"Inserting U+%04X '%lc' (colors %" G_GUINT64_FORMAT ") (%ld+%d, %ld), delta = %ld; ",do { } while(0)
                       (unsigned int)c, g_unichar_isprint(c) ? c : 0xfffd,do { } while(0)
                       m_color_defaults.attr.colors(),do { } while(0)
                      col, columns, (long)m_screen->cursor.row,do { } while(0)
	(long)m_screen->insert_delta)do { } while(0);

      //FIXMEchpe
      if (G_UNLIKELY(c == 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_984; if
 (c == 0) _g_boolean_var_984 = 1; else _g_boolean_var_984 = 0
; _g_boolean_var_984; }), 0)))
              goto not_inserted;

if (G_UNLIKELY (columns == 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_985; if
 (columns == 0) _g_boolean_var_985 = 1; else _g_boolean_var_985
 = 0; _g_boolean_var_985; }), 0))) {

/* It's a combining mark */

long row_num;
BteCell *cell;

_bte_debug_print(BTE_DEBUG_PARSER, "combining U+%04X", c)do { } while(0);

              row_num = m_screen->cursor.row;
row = NULL__null;
if (G_UNLIKELY (col == 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_986; if
 (col == 0) _g_boolean_var_986 = 1; else _g_boolean_var_986 =
 0; _g_boolean_var_986; }), 0))) {
	/* We are at first column.  See if the previous line softwrapped.
	 * If it did, move there.  Otherwise skip inserting. */

	if (G_LIKELY (row_num > 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_987; if
 (row_num > 0) _g_boolean_var_987 = 1; else _g_boolean_var_987
 = 0; _g_boolean_var_987; }), 1))) {
		row_num--;
		row = find_row_data_writable(row_num);

		if (row) {
			if (!row->attr.soft_wrapped)
				row = NULL__null;
			else
				col = _bte_row_data_length (row)((row)->len + 0);
		}
	}
} else {
	row = find_row_data_writable(row_num);
}

if (G_UNLIKELY (!row || !col)(__builtin_expect (__extension__ ({ int _g_boolean_var_988; if
 (!row || !col) _g_boolean_var_988 = 1; else _g_boolean_var_988
 = 0; _g_boolean_var_988; }), 0)))
	goto not_inserted;

/* Combine it on the previous cell */

col--;
cell = _bte_row_data_get_writable (row, col);

if (G_UNLIKELY (!cell)(__builtin_expect (__extension__ ({ int _g_boolean_var_989; if
 (!cell) _g_boolean_var_989 = 1; else _g_boolean_var_989 = 0;
 _g_boolean_var_989; }), 0)))
	goto not_inserted;

/* Find the previous cell */
while (cell && cell->attr.fragment() && col > 0)
	cell = _bte_row_data_get_writable (row, --col);
if (G_UNLIKELY (!cell || cell->c == '\t')(__builtin_expect (__extension__ ({ int _g_boolean_var_990; if
 (!cell || cell->c == '\t') _g_boolean_var_990 = 1; else _g_boolean_var_990
 = 0; _g_boolean_var_990; }), 0)))
	goto not_inserted;

/* Combine the new character on top of the cell string */
c = _bte_unistr_append_unichar (cell->c, c);

/* And set it */
columns = cell->attr.columns();
for (i = 0; i < columns; i++) {
	cell = _bte_row_data_get_writable (row, col++);
	cell->c = c;
}

goto done;
      } else {
              m_last_graphic_character = c_unmapped;
}

/* Make sure we have enough rows to hold this data. */
row = ensure_cursor();
g_assert(row != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_991
; if (row != __null) _g_boolean_var_991 = 1; else _g_boolean_var_991
 = 0; _g_boolean_var_991; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 2965, ((const char*) (__PRETTY_FUNCTION__
)), "row != NULL"); } while (0);

if (insert) {
              cleanup_fragments(col, col);
for (i = 0; i < columns; i++)
                      _bte_row_data_insert (row, col + i, &basic_cell);
} else {
              cleanup_fragments(col, col + columns);
_bte_row_data_fill (row, &basic_cell, col + columns);
}

      attr = m_defaults.attr;
attr.set_columns(columns);

{
BteCell *pcell = _bte_row_data_get_writable (row, col);
pcell->c = c;
pcell->attr = attr;
col++;
}

/* insert wide-char fragments */
attr.set_fragment(true);
for (i = 1; i < columns; i++) {
BteCell *pcell = _bte_row_data_get_writable (row, col);
pcell->c = c;
pcell->attr = attr;
col++;
}
if (_bte_row_data_length (row)((row)->len + 0) > m_column_count)
cleanup_fragments(m_column_count, _bte_row_data_length (row)((row)->len + 0));
_bte_row_data_shrink (row, m_column_count);

      m_screen->cursor.col = col;

3000done:
      /* Signal that this part of the window needs drawing. */
      if (G_UNLIKELY (invalidate_now)(__builtin_expect (__extension__ ({ int _g_boolean_var_992; if
 (invalidate_now) _g_boolean_var_992 = 1; else _g_boolean_var_992
 = 0; _g_boolean_var_992; }), 0))) {
              invalidate_row_and_context(m_screen->cursor.row);
      }

/* We added text, so make a note of it. */
m_text_inserted_flag = TRUE(!(0));

3009not_inserted:
_bte_debug_print(BTE_DEBUG_ADJ|BTE_DEBUG_PARSER,do { } while(0)
	"insertion delta => %ld.\n",do { } while(0)
	(long)m_screen->insert_delta)do { } while(0);

      m_line_wrapped = line_wrapped;
3015}

3017guint8
3018Terminal::get_bidi_flags() const noexcept
3019{
      return (m_modes_ecma.BDSM() ? BTE_BIDI_FLAG_IMPLICIT : 0) |
             (m_bidi_rtl ? BTE_BIDI_FLAG_RTL : 0) |
             (m_modes_private.BTE_BIDI_AUTO() ? BTE_BIDI_FLAG_AUTO : 0) |
             (m_modes_private.BTE_BIDI_BOX_MIRROR() ? BTE_BIDI_FLAG_BOX_MIRROR : 0);
3024}

3026/* Apply the specified BiDi parameters on the paragraph beginning at the specified line. */
3027void
3028Terminal::apply_bidi_attributes(bte::grid::row_t start, guint8 bidi_flags, guint8 bidi_flags_mask)
3029{
      bte::grid::row_t row = start;
      BteRowData *rowdata;

      bidi_flags &= bidi_flags_mask;

      _bte_debug_print(BTE_DEBUG_BIDI,do { } while(0)
                       "Applying BiDi parameters from row %ld.\n", row)do { } while(0);

      rowdata = _bte_ring_index_writable (m_screen->row_data, row);
      if (rowdata == nullptr || (rowdata->attr.bidi_flags & bidi_flags_mask) == bidi_flags) {
              _bte_debug_print(BTE_DEBUG_BIDI,do { } while(0)
                               "BiDi parameters didn't change for this paragraph.\n")do { } while(0);
              return;
      }

      while (true) {
              rowdata->attr.bidi_flags &= ~bidi_flags_mask;
              rowdata->attr.bidi_flags |= bidi_flags;

              if (!rowdata->attr.soft_wrapped)
                      break;

              rowdata = _bte_ring_index_writable (m_screen->row_data, row + 1);
              if (rowdata == nullptr)
                      break;
              row++;
      }

      _bte_debug_print(BTE_DEBUG_BIDI,do { } while(0)
                       "Applied BiDi parameters to rows %ld..%ld.\n", start, row)do { } while(0);

      m_ringview.invalidate();
      invalidate_rows(start, row);
3063}

3065/* Apply the current BiDi parameters covered by bidi_flags_mask on the current paragraph
* if the cursor is at the first position of this paragraph. */
3067void
3068Terminal::maybe_apply_bidi_attributes(guint8 bidi_flags_mask)
3069{
      _bte_debug_print(BTE_DEBUG_BIDI,do { } while(0)
                       "Maybe applying BiDi parameters on current paragraph.\n")do { } while(0);

      if (m_screen->cursor.col != 0) {
              _bte_debug_print(BTE_DEBUG_BIDI,do { } while(0)
                               "No, cursor not in first column.\n")do { } while(0);
              return;
      }

      auto row = m_screen->cursor.row;

      if (row > _bte_ring_delta (m_screen->row_data)) {
              const BteRowData *rowdata = _bte_ring_index (m_screen->row_data, row - 1);
              if (rowdata != nullptr && rowdata->attr.soft_wrapped) {
                      _bte_debug_print(BTE_DEBUG_BIDI,do { } while(0)
                                       "No, we're not after a hard wrap.\n")do { } while(0);
                      return;
              }
      }

      _bte_debug_print(BTE_DEBUG_BIDI,do { } while(0)
                       "Yes, applying.\n")do { } while(0);

      apply_bidi_attributes (row, get_bidi_flags(), bidi_flags_mask);
3094}

3096static void
3097reaper_child_exited_cb(BteReaper *reaper,
                     int ipid,
                     int status,
                     bte::terminal::Terminal* that) noexcept
3101try
3102{
      that->child_watch_done(pid_t{ipid}, status);
      // @that might be destroyed at this point
3105}
3106catch (...)
3107{
      bte::log_exception();
3109}

3111void
3112Terminal::child_watch_done(pid_t pid,
                         int status)
3114{
if (pid != m_pty_pid)
              return;

      _BTE_DEBUG_IF (BTE_DEBUG_LIFECYCLE)if (0) {
              g_printerr ("Child[%d] exited with status %d\n",
                          pid, status);
3121#ifdef HAVE_SYS_WAIT_H
              if (WIFEXITED (status)(((status) & 0x7f) == 0)) {
                      g_printerr ("Child[%d] exit code %d.\n",
                                  pid, WEXITSTATUS (status)(((status) & 0xff00) >> 8));
              } else if (WIFSIGNALED (status)(((signed char) (((status) & 0x7f) + 1) >> 1) > 0
)) {
                      g_printerr ("Child[%d] dies with signal %d.\n",
                                  pid, WTERMSIG (status)((status) & 0x7f));
              }
3129#endif
      }

      /* Disconnect from the reaper */
      if (m_reaper) {
              g_signal_handlers_disconnect_by_func(m_reaper,g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this))
                                                   (gpointer)reaper_child_exited_cb,g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this))
                                                   this)g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this));
              g_object_unref(m_reaper);
              m_reaper = nullptr;
      }

      m_pty_pid = -1;

      /* If we still have a PTY, or data to process, defer emitting the signals
       * until we have EOF on the PTY, so that we can process all pending data.
       */
      if (pty() || !m_incoming_queue.empty()) {
              m_child_exit_status = status;
              m_child_exited_after_eos_pending = true;

              m_child_exited_eos_wait_timer.schedule_seconds(2); // FIXME: better value?
      } else {
              m_child_exited_after_eos_pending = false;

              if (widget())
                      widget()->emit_child_exited(status);
      }
3157}

3159static void
3160mark_input_source_invalid_cb(bte::terminal::Terminal* that)
3161{
_bte_debug_print (BTE_DEBUG_IO, "Removed PTY input source\n")do { } while(0);
that->m_pty_input_source = 0;
3164}

3166/* Read and handle data from the child. */
3167static gboolean
3168io_read_cb(int fd,
         GIOCondition condition,
         bte::terminal::Terminal* that)
3171{
      return that->pty_io_read(fd, condition);
3173}

3175void
3176Terminal::connect_pty_read()
3177{
if (m_pty_input_source != 0 || !pty())
return;

      _bte_debug_print (BTE_DEBUG_IO, "Adding PTY input source\n")do { } while(0);

      m_pty_input_source = g_unix_fd_add_full(BTE_CHILD_INPUT_PRIORITY200,
                                              pty()->fd(),
                                              (GIOCondition)(G_IO_IN | G_IO_PRI | G_IO_HUP | G_IO_ERR),
                                              (GUnixFDSourceFunc)io_read_cb,
                                              this,
                                              (GDestroyNotify)mark_input_source_invalid_cb);
3189}

3191static void
3192mark_output_source_invalid_cb(bte::terminal::Terminal* that)
3193{
_bte_debug_print (BTE_DEBUG_IO, "Removed PTY output source\n")do { } while(0);
that->m_pty_output_source = 0;
3196}

3198/* Send locally-encoded characters to the child. */
3199static gboolean
3200io_write_cb(int fd,
          GIOCondition condition,
          bte::terminal::Terminal* that)
3203{
      return that->pty_io_write(fd, condition);
3205}

3207void
3208Terminal::connect_pty_write()
3209{
      if (m_pty_output_source != 0 || !pty())
              return;

      g_warn_if_fail(m_input_enabled)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_993
; if (m_input_enabled) _g_boolean_var_993 = 1; else _g_boolean_var_993
 = 0; _g_boolean_var_993; }), 1)) ; else g_warn_message ("BTE"
, "../src/bte.cc", 3213, ((const char*) (__PRETTY_FUNCTION__)
), "m_input_enabled"); } while (0);

      /* Anything to write? */
      if (_bte_byte_array_length(m_outgoing)((m_outgoing)->len) == 0)
              return;

      /* Do one write. FIXMEchpe why? */
      if (!pty_io_write (pty()->fd(), G_IO_OUT))
              return;

      _bte_debug_print (BTE_DEBUG_IO, "Adding PTY output source\n")do { } while(0);

      m_pty_output_source = g_unix_fd_add_full(BTE_CHILD_OUTPUT_PRIORITY-100,
                                               pty()->fd(),
                                               G_IO_OUT,
                                               (GUnixFDSourceFunc)io_write_cb,
                                               this,
                                               (GDestroyNotify)mark_output_source_invalid_cb);
3231}

3233void
3234Terminal::disconnect_pty_read()
3235{
if (m_pty_input_source != 0) {
_bte_debug_print (BTE_DEBUG_IO, "Removing PTY input source\n")do { } while(0);
g_source_remove(m_pty_input_source);
              // FIXMEchpe the destroy notify should already have done this!
m_pty_input_source = 0;
}
3242}

3244void
3245Terminal::disconnect_pty_write()
3246{
if (m_pty_output_source != 0) {
_bte_debug_print (BTE_DEBUG_IO, "Removing PTY output source\n")do { } while(0);
g_source_remove(m_pty_output_source);
              // FIXMEchpe the destroy notify should already have done this!
m_pty_output_source = 0;
}
3253}

3255void
3256Terminal::pty_termios_changed()
3257{
      _bte_debug_print(BTE_DEBUG_IO, "Termios changed\n")do { } while(0);
3259}

3261void
3262Terminal::pty_scroll_lock_changed(bool locked)
3263{
      _bte_debug_print(BTE_DEBUG_IO, "Output %s (^%c)\n",do { } while(0)
                       locked ? "stopped" : "started",do { } while(0)
                       locked ? 'Q' : 'S')do { } while(0);
3267}

3269/*
* Terminal::watch_child:
* @child_pid: a #pid_t
*
* Watches @child_pid. When the process exists, the #BteTerminal::child-exited
* signal will be called with the child's exit status.
*
* Prior to calling this function, a #BtePty must have been set in @terminal
* using bte_terminal_set_pty().
* When the child exits, the terminal's #BtePty will be set to %NULL.
*
* Note: g_child_watch_add() or g_child_watch_add_full() must not have
* been called for @child_pid, nor a #GSource for it been created with
* g_child_watch_source_new().
*
* Note: when using the g_spawn_async() family of functions,
* the %G_SPAWN_DO_NOT_REAP_CHILD flag MUST have been passed.
*/
3287void
3288Terminal::watch_child (pid_t child_pid)
3289{
      // FIXMEchpe: support passing child_pid = -1 to remove the wathch
      g_assert(child_pid != -1)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_994
; if (child_pid != -1) _g_boolean_var_994 = 1; else _g_boolean_var_994
 = 0; _g_boolean_var_994; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 3291, ((const char*) (__PRETTY_FUNCTION__
)), "child_pid != -1"); } while (0);
      if (!pty())
              return;

      auto const freezer = bte::glib::FreezeObjectNotify{m_terminal};

      /* Set this as the child's pid. */
      m_pty_pid = child_pid;

      /* Catch a child-exited signal from the child pid. */
      auto reaper = bte_reaper_ref();
      bte_reaper_add_child(child_pid);
      if (reaper != m_reaper) {
              if (m_reaper) {
                      g_signal_handlers_disconnect_by_func(m_reaper,g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this))
                                                           (gpointer)reaper_child_exited_cb,g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this))
                                                           this)g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this));
                      g_object_unref(m_reaper);
              }
              m_reaper = reaper; /* adopts */
              g_signal_connect(m_reaper, "child-exited",g_signal_connect_data ((m_reaper), ("child-exited"), (((GCallback
) (reaper_child_exited_cb))), (this), __null, (GConnectFlags)
 0)
                               G_CALLBACK(reaper_child_exited_cb),g_signal_connect_data ((m_reaper), ("child-exited"), (((GCallback
) (reaper_child_exited_cb))), (this), __null, (GConnectFlags)
 0)
                               this)g_signal_connect_data ((m_reaper), ("child-exited"), (((GCallback
) (reaper_child_exited_cb))), (this), __null, (GConnectFlags)
 0);
      } else {
              g_object_unref(reaper);
      }

      /* FIXMEchpe: call set_size() here? */
3319}

3321/* Reset the input method context. */
3322void
3323Terminal::im_reset()
3324{
      if (widget())
              widget()->im_reset();

      im_preedit_reset();
3329}

3331void
3332Terminal::process_incoming()
3333{
      switch (data_syntax()) {
      case DataSyntax::eECMA48_UTF8:   process_incoming_utf8();    break;
3336#ifdef WITH_ICU
      case DataSyntax::eECMA48_PCTERM: process_incoming_pcterm(); break;
3338#endif
      default: g_assert_not_reached()do { g_assertion_message_expr ("BTE", "../src/bte.cc", 3339, (
(const char*) (__PRETTY_FUNCTION__)), __null); } while (0); break;
      }
3341}


3344/* Note that this code is mostly copied to process_incoming_pcterm() below; any non-charset-decoding
* related changes made here need to be made there, too.
* FIXMEchpe: refactor this to share more code with process_incoming_pcterm().
*/
3348void
3349Terminal::process_incoming_utf8()
3350{
BteVisualPosition saved_cursor;
gboolean saved_cursor_visible;
      CursorStyle saved_cursor_style;
      bte::grid::row_t bbox_top, bbox_bottom;
gboolean modified, bottom;
gboolean invalidated_text;
gboolean in_scroll_region;

_bte_debug_print(BTE_DEBUG_IO,do { } while(0)
                       "Handler processing %" G_GSIZE_FORMAT " bytes over %" G_GSIZE_FORMAT " chunks.\n",do { } while(0)
                       m_input_bytes,do { } while(0)
                       m_incoming_queue.size())do { } while(0);
_bte_debug_print (BTE_DEBUG_WORK, "(")do { } while(0);

      auto previous_screen = m_screen;

      bottom = m_screen->insert_delta == (long)m_screen->scroll_delta;

/* Save the current cursor position. */
      saved_cursor = m_screen->cursor;
saved_cursor_visible = m_modes_private.DEC_TEXT_CURSOR();
      saved_cursor_style = m_cursor_style;

      in_scroll_region = m_scrolling_restricted
          && (m_screen->cursor.row >= (m_screen->insert_delta + m_scrolling_region.start))
          && (m_screen->cursor.row <= (m_screen->insert_delta + m_scrolling_region.end));

/* We should only be called when there's data to process. */
g_assert(!m_incoming_queue.empty())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_995
; if (!m_incoming_queue.empty()) _g_boolean_var_995 = 1; else
 _g_boolean_var_995 = 0; _g_boolean_var_995; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 3379, ((const char*) (__PRETTY_FUNCTION__
)), "!m_incoming_queue.empty()"); } while (0);

modified = FALSE(0);
invalidated_text = FALSE(0);

      bbox_bottom = -G_MAXINT2147483647;
      bbox_top = G_MAXINT2147483647;

      bte::parser::Sequence seq{m_parser};

      m_line_wrapped = false;

      size_t bytes_processed = 0;

      while (!m_incoming_queue.empty()) {
              auto chunk = std::move(m_incoming_queue.front());
              m_incoming_queue.pop();

              g_assert_nonnull(chunk.get())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_996
; if ((chunk.get()) != nullptr) _g_boolean_var_996 = 1; else _g_boolean_var_996
 = 0; _g_boolean_var_996; }), 1)) ; else g_assertion_message (
"BTE", "../src/bte.cc", 3397, ((const char*) (__PRETTY_FUNCTION__
)), "'" "chunk.get()" "' should not be nullptr"); } while (0);

              _BTE_DEBUG_IF(BTE_DEBUG_IO)if (0) {
                      _bte_debug_hexdump("Incoming buffer", chunk->data, chunk->len);
              }

              bytes_processed += chunk->len;

              auto const* ip = chunk->data;
              auto const* iend = chunk->data + chunk->len;

              for ( ; ip < iend; ++ip) {

                      switch (m_utf8_decoder.decode(*ip)) {
                      case bte::base::UTF8Decoder::REJECT_REWIND:
                              /* Rewind the stream.
                               * Note that this will never lead to a loop, since in the
                               * next round this byte *will* be consumed.
                               */
                              --ip;
                              [[fallthrough]];
                      case bte::base::UTF8Decoder::REJECT:
                              m_utf8_decoder.reset();
                              /* Fall through to insert the U+FFFD replacement character. */
                              [[fallthrough]];
                      case bte::base::UTF8Decoder::ACCEPT: {
                              auto rv = m_parser.feed(m_utf8_decoder.codepoint());
                              if (G_UNLIKELY(rv < 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_997; if
 (rv < 0) _g_boolean_var_997 = 1; else _g_boolean_var_997 =
 0; _g_boolean_var_997; }), 0))) {
3425#ifdef DEBUG
                                      uint32_t c = m_utf8_decoder.codepoint();
                                      char c_buf[7];
                                      g_snprintf(c_buf, sizeof(c_buf), "%lc", c);
                                      char const* wp_str = g_unichar_isprint(c) ? c_buf : _bte_debug_sequence_to_string(c_buf, -1);
                                      _bte_debug_print(BTE_DEBUG_PARSER, "Parser error on U+%04X [%s]!\n",do { } while(0)
                                                       c, wp_str)do { } while(0);
3432#endif
                                      break;
                              }

3436#ifdef BTE_DEBUG
                              if (rv != BTE_SEQ_NONE)
                                      g_assert((bool)seq)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_998
; if ((bool)seq) _g_boolean_var_998 = 1; else _g_boolean_var_998
 = 0; _g_boolean_var_998; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 3438, ((const char*) (__PRETTY_FUNCTION__
)), "(bool)seq"); } while (0);
3439#endif

                              _BTE_DEBUG_IF(BTE_DEBUG_PARSER)if (0) {
                                      if (rv != BTE_SEQ_NONE) {
                                              seq.print();
                                      }
                              }

                              // FIXMEchpe this assumes that the only handler inserting
                              // a character is GRAPHIC, which isn't true (at least ICH, REP, SUB
                              // also do, and invalidate directly for now)...

                              switch (rv) {
                              case BTE_SEQ_GRAPHIC: {

                                      bbox_top = std::min(bbox_top,
                                                          m_screen->cursor.row);

                                      // does insert_char(c, false, false)
                                      GRAPHIC(seq);
                                      _bte_debug_print(BTE_DEBUG_PARSER,do { } while(0)
                                                       "Last graphic is now U+%04X %lc\n",do { } while(0)
                                                       m_last_graphic_character,do { } while(0)
                                                       g_unichar_isprint(m_last_graphic_character) ? m_last_graphic_character : 0xfffd)do { } while(0);

                                      if (m_line_wrapped) {
                                              m_line_wrapped = false;
                                              /* line wrapped, correct bbox */
                                              if (invalidated_text &&
                                                  (m_screen->cursor.row > bbox_bottom + BTE_CELL_BBOX_SLACK1 ||
                                                   m_screen->cursor.row < bbox_top - BTE_CELL_BBOX_SLACK1)) {
                                                      invalidate_rows_and_context(bbox_top, bbox_bottom);
                                                      bbox_bottom = -G_MAXINT2147483647;
                                                      bbox_top = G_MAXINT2147483647;
                                              }
                                              bbox_top = std::min(bbox_top,
                                                                  m_screen->cursor.row);
                                      }
                                      /* Add the cells over which we have moved to the region
                                       * which we need to refresh for the user. */
                                      bbox_bottom = std::max(bbox_bottom,
                                                             m_screen->cursor.row);
                                      invalidated_text = TRUE(!(0));

                                      /* We *don't* emit flush pending signals here. */
                                      modified = TRUE(!(0));

                                      break;
                              }

                              case BTE_SEQ_NONE:
                              case BTE_SEQ_IGNORE:
                                      break;

                              default: {
                                      switch (seq.command()) {
3495#define _BTE_CMD(cmd)   case BTE_CMD_##cmd: cmd(seq); break;
3496#define _BTE_NOP(cmd)
3497#include "parser-cmd.hh"
3498#undef _BTE_CMD
3499#undef _BTE_NOP
                                      default:
                                              _bte_debug_print(BTE_DEBUG_PARSER,do { } while(0)
                                                               "Unknown parser command %d\n", seq.command())do { } while(0);
                                              break;
                                      }

                                      m_last_graphic_character = 0;

                                      modified = TRUE(!(0));

                                      // FIXME m_screen may be != previous_screen, check for that!

                                      gboolean new_in_scroll_region = m_scrolling_restricted
                                              && (m_screen->cursor.row >= (m_screen->insert_delta + m_scrolling_region.start))
                                              && (m_screen->cursor.row <= (m_screen->insert_delta + m_scrolling_region.end));

                                      /* if we have moved greatly during the sequence handler, or moved
                                       * into a scroll_region from outside it, restart the bbox.
                                       */
                                      if (invalidated_text &&
                                          ((new_in_scroll_region && !in_scroll_region) ||
                                           (m_screen->cursor.row > bbox_bottom + BTE_CELL_BBOX_SLACK1 ||
                                            m_screen->cursor.row < bbox_top - BTE_CELL_BBOX_SLACK1))) {
                                              invalidate_rows_and_context(bbox_top, bbox_bottom);
                                              invalidated_text = FALSE(0);
                                              bbox_bottom = -G_MAXINT2147483647;
                                              bbox_top = G_MAXINT2147483647;
                                      }

                                      in_scroll_region = new_in_scroll_region;

                                      break;
                              }
                              }
                              break;
                      }
                      }
              }

              if (chunk->eos()) {
                      m_eos_pending = true;
                      /* If there's an unfinished character in the queue, insert a replacement character */
                      if (m_utf8_decoder.flush()) {
                              insert_char(m_utf8_decoder.codepoint(), false, true);
                      }

                      break;
              }
      }

3550#ifdef BTE_DEBUG
/* Some safety checks: ensure the visible parts of the buffer
 * are all in the buffer. */
g_assert_cmpint(m_screen->insert_delta, >=, _bte_ring_delta(m_screen->row_data))do { gint64 __n1 = (m_screen->insert_delta), __n2 = (_bte_ring_delta
(m_screen->row_data)); if (__n1 >= __n2) ; else g_assertion_message_cmpnum
 ("BTE", "../src/bte.cc", 3553, ((const char*) (__PRETTY_FUNCTION__
)), "m_screen->insert_delta" " " ">=" " " "_bte_ring_delta(m_screen->row_data)"
, (long double) __n1, ">=", (long double) __n2, 'i'); } while
 (0);

/* The cursor shouldn't be above or below the addressable
 * part of the display buffer. */
              g_assert_cmpint(m_screen->cursor.row, >=, m_screen->insert_delta)do { gint64 __n1 = (m_screen->cursor.row), __n2 = (m_screen
->insert_delta); if (__n1 >= __n2) ; else g_assertion_message_cmpnum
 ("BTE", "../src/bte.cc", 3557, ((const char*) (__PRETTY_FUNCTION__
)), "m_screen->cursor.row" " " ">=" " " "m_screen->insert_delta"
, (long double) __n1, ">=", (long double) __n2, 'i'); } while
 (0);
3558#endif

if (modified) {
/* Keep the cursor on-screen if we scroll on output, or if
 * we're currently at the bottom of the buffer. */
update_insert_delta();
if (m_scroll_on_output || bottom) {
	maybe_scroll_to_bottom();
}
/* Deselect the current selection if its contents are changed
 * by this insertion. */
              if (!m_selection_resolved.empty()) {
                      //FIXMEchpe: this is atrocious
	auto selection = get_selected_text();
	if ((selection == nullptr) ||
	    (m_selection[BTE_SELECTION_PRIMARY] == nullptr) ||
	    (strcmp(selection->str, m_selection[BTE_SELECTION_PRIMARY]->str) != 0)) {
		deselect_all();
	}
                      if (selection)
                              g_string_free(selection, TRUE(!(0)));
}
}

if (modified || (m_screen != previous_screen)) {
              m_ringview.invalidate();
/* Signal that the visible contents changed. */
queue_contents_changed();
}

emit_pending_signals();

if (invalidated_text) {
              invalidate_rows_and_context(bbox_top, bbox_bottom);
}

      if ((saved_cursor.col != m_screen->cursor.col) ||
          (saved_cursor.row != m_screen->cursor.row)) {
/* invalidate the old and new cursor positions */
if (saved_cursor_visible)
                      invalidate_row(saved_cursor.row);
invalidate_cursor_once();
check_cursor_blink();
/* Signal that the cursor moved. */
queue_cursor_moved();
      } else if ((saved_cursor_visible != m_modes_private.DEC_TEXT_CURSOR()) ||
                 (saved_cursor_style != m_cursor_style)) {
              invalidate_row(saved_cursor.row);
check_cursor_blink();
}

/* Tell the input method where the cursor is. */
      im_update_cursor();

      /* After processing some data, do a hyperlink GC. The multiplier is totally arbitrary, feel free to fine tune. */
      _bte_ring_hyperlink_maybe_gc(m_screen->row_data, bytes_processed * 8);

_bte_debug_print (BTE_DEBUG_WORK, ")")do { } while(0);
_bte_debug_print (BTE_DEBUG_IO,do { } while(0)
                        "%" G_GSIZE_FORMAT " bytes in %" G_GSIZE_FORMAT " chunks left to process.\n",do { } while(0)
                        m_input_bytes,do { } while(0)
                        m_incoming_queue.size())do { } while(0);
3620}

3622#ifdef WITH_ICU

3624/* Note that this is mostly a copy of process_incoming_utf8() above; any non-charset-decoding
* related changes made here need to be made there, too.
* FIXMEchpe: refactor this to share more code with process_incoming_utf8().
*/
3628void
3629Terminal::process_incoming_pcterm()
3630{
BteVisualPosition saved_cursor;
gboolean saved_cursor_visible;
      CursorStyle saved_cursor_style;
      bte::grid::row_t bbox_top, bbox_bottom;
gboolean modified, bottom;
gboolean invalidated_text;
gboolean in_scroll_region;

_bte_debug_print(BTE_DEBUG_IO,do { } while(0)
                       "Handler processing %" G_GSIZE_FORMAT " bytes over %" G_GSIZE_FORMAT " chunks.\n",do { } while(0)
                       m_input_bytes,do { } while(0)
                       m_incoming_queue.size())do { } while(0);
_bte_debug_print (BTE_DEBUG_WORK, "(")do { } while(0);

      auto previous_screen = m_screen;

      bottom = m_screen->insert_delta == (long)m_screen->scroll_delta;

/* Save the current cursor position. */
      saved_cursor = m_screen->cursor;
saved_cursor_visible = m_modes_private.DEC_TEXT_CURSOR();
      saved_cursor_style = m_cursor_style;

      in_scroll_region = m_scrolling_restricted
          && (m_screen->cursor.row >= (m_screen->insert_delta + m_scrolling_region.start))
          && (m_screen->cursor.row <= (m_screen->insert_delta + m_scrolling_region.end));

/* We should only be called when there's data to process. */
g_assert(!m_incoming_queue.empty())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_999
; if (!m_incoming_queue.empty()) _g_boolean_var_999 = 1; else
 _g_boolean_var_999 = 0; _g_boolean_var_999; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 3659, ((const char*) (__PRETTY_FUNCTION__
)), "!m_incoming_queue.empty()"); } while (0);

modified = FALSE(0);
invalidated_text = FALSE(0);

      bbox_bottom = -G_MAXINT2147483647;
      bbox_top = G_MAXINT2147483647;

      bte::parser::Sequence seq{m_parser};

      m_line_wrapped = false;

      size_t bytes_processed = 0;

      auto& decoder = m_converter->decoder();

      while (!m_incoming_queue.empty()) {
              auto chunk = std::move(m_incoming_queue.front());
              m_incoming_queue.pop();

              g_assert_nonnull(chunk.get())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1000
; if ((chunk.get()) != nullptr) _g_boolean_var_1000 = 1; else
 _g_boolean_var_1000 = 0; _g_boolean_var_1000; }), 1)) ; else
 g_assertion_message ("BTE", "../src/bte.cc", 3679, ((const char
*) (__PRETTY_FUNCTION__)), "'" "chunk.get()" "' should not be nullptr"
); } while (0);

              _BTE_DEBUG_IF(BTE_DEBUG_IO)if (0) {
                      _bte_debug_hexdump("Incoming buffer", chunk->data, chunk->len);
              }

              bytes_processed += chunk->len;

              auto const* ip = chunk->data;
              auto const* iend = chunk->data + chunk->len;

              auto eos = bool{false};
              auto flush = bool{false};

      start:
              while (ip < iend || flush) {
                      switch (decoder.decode(&ip, flush)) {
                      case bte::base::ICUDecoder::Result::eSomething: {
                              auto rv = m_parser.feed(decoder.codepoint());
                              if (G_UNLIKELY(rv < 0)(__builtin_expect (__extension__ ({ int _g_boolean_var_1001; if
 (rv < 0) _g_boolean_var_1001 = 1; else _g_boolean_var_1001
 = 0; _g_boolean_var_1001; }), 0))) {
3699#ifdef BTE_DEBUG
                                      uint32_t c = decoder.codepoint();
                                      char c_buf[7];
                                      g_snprintf(c_buf, sizeof(c_buf), "%lc", c);
                                      char const* wp_str = g_unichar_isprint(c) ? c_buf : _bte_debug_sequence_to_string(c_buf, -1);
                                      _bte_debug_print(BTE_DEBUG_PARSER, "Parser error on U+%04X [%s]!\n",do { } while(0)
                                                       c, wp_str)do { } while(0);
3706#endif
                                      break;
                              }

3710#ifdef BTE_DEBUG
                              if (rv != BTE_SEQ_NONE)
                                      g_assert((bool)seq)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1002
; if ((bool)seq) _g_boolean_var_1002 = 1; else _g_boolean_var_1002
 = 0; _g_boolean_var_1002; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 3712, ((const char*) (__PRETTY_FUNCTION__
)), "(bool)seq"); } while (0);
3713#endif

                              _BTE_DEBUG_IF(BTE_DEBUG_PARSER)if (0) {
                                      if (rv != BTE_SEQ_NONE) {
                                              seq.print();
                                      }
                              }

                              // FIXMEchpe this assumes that the only handler inserting
                              // a character is GRAPHIC, which isn't true (at least ICH, REP, SUB
                              // also do, and invalidate directly for now)...

                              switch (rv) {
                              case BTE_SEQ_GRAPHIC: {

                                      bbox_top = std::min(bbox_top,
                                                          m_screen->cursor.row);

                                      // does insert_char(c, false, false)
                                      GRAPHIC(seq);
                                      _bte_debug_print(BTE_DEBUG_PARSER,do { } while(0)
                                                       "Last graphic is now U+%04X %lc\n",do { } while(0)
                                                       m_last_graphic_character,do { } while(0)
                                                       g_unichar_isprint(m_last_graphic_character) ? m_last_graphic_character : 0xfffd)do { } while(0);

                                      if (m_line_wrapped) {
                                              m_line_wrapped = false;
                                              /* line wrapped, correct bbox */
                                              if (invalidated_text &&
                                                  (m_screen->cursor.row > bbox_bottom + BTE_CELL_BBOX_SLACK1 ||
                                                   m_screen->cursor.row < bbox_top - BTE_CELL_BBOX_SLACK1)) {
                                                      invalidate_rows_and_context(bbox_top, bbox_bottom);
                                                      bbox_bottom = -G_MAXINT2147483647;
                                                      bbox_top = G_MAXINT2147483647;
                                              }
                                              bbox_top = std::min(bbox_top,
                                                                  m_screen->cursor.row);
                                      }
                                      /* Add the cells over which we have moved to the region
                                       * which we need to refresh for the user. */
                                      bbox_bottom = std::max(bbox_bottom,
                                                             m_screen->cursor.row);
                                      invalidated_text = TRUE(!(0));

                                      /* We *don't* emit flush pending signals here. */
                                      modified = TRUE(!(0));

                                      break;
                              }

                              case BTE_SEQ_NONE:
                              case BTE_SEQ_IGNORE:
                                      break;

                              default: {
                                      switch (seq.command()) {
3769#define _BTE_CMD(cmd)   case BTE_CMD_##cmd: cmd(seq); break;
3770#define _BTE_NOP(cmd)
3771#include "parser-cmd.hh"
3772#undef _BTE_CMD
3773#undef _BTE_NOP
                                      default:
                                              _bte_debug_print(BTE_DEBUG_PARSER,do { } while(0)
                                                               "Unknown parser command %d\n", seq.command())do { } while(0);
                                              break;
                                      }

                                      m_last_graphic_character = 0;

                                      modified = TRUE(!(0));

                                      // FIXME m_screen may be != previous_screen, check for that!

                                      gboolean new_in_scroll_region = m_scrolling_restricted
                                              && (m_screen->cursor.row >= (m_screen->insert_delta + m_scrolling_region.start))
                                              && (m_screen->cursor.row <= (m_screen->insert_delta + m_scrolling_region.end));

                                      /* if we have moved greatly during the sequence handler, or moved
                                       * into a scroll_region from outside it, restart the bbox.
                                       */
                                      if (invalidated_text &&
                                          ((new_in_scroll_region && !in_scroll_region) ||
                                           (m_screen->cursor.row > bbox_bottom + BTE_CELL_BBOX_SLACK1 ||
                                            m_screen->cursor.row < bbox_top - BTE_CELL_BBOX_SLACK1))) {
                                              invalidate_rows_and_context(bbox_top, bbox_bottom);
                                              invalidated_text = FALSE(0);
                                              bbox_bottom = -G_MAXINT2147483647;
                                              bbox_top = G_MAXINT2147483647;
                                      }

                                      in_scroll_region = new_in_scroll_region;

                                      break;
                              }
                              }
                              break;
                      }
                      case bte::base::ICUDecoder::Result::eNothing:
                              flush = false;
                              break;

                      case bte::base::ICUDecoder::Result::eError:
                              // FIXMEchpe do we need ++ip here?
                              decoder.reset();
                              break;

                      }
              }

              if (eos) {
                      /* Done processing the last chunk */
                      m_eos_pending = true;
                      break;
              }

              if (chunk->eos()) {
                      /* On EOS, we still need to flush the decoder before we can finish */
                      eos = flush = true;
                      goto start;
              }
      }

3835#ifdef BTE_DEBUG
/* Some safety checks: ensure the visible parts of the buffer
 * are all in the buffer. */
g_assert_cmpint(m_screen->insert_delta, >=, _bte_ring_delta(m_screen->row_data))do { gint64 __n1 = (m_screen->insert_delta), __n2 = (_bte_ring_delta
(m_screen->row_data)); if (__n1 >= __n2) ; else g_assertion_message_cmpnum
 ("BTE", "../src/bte.cc", 3838, ((const char*) (__PRETTY_FUNCTION__
)), "m_screen->insert_delta" " " ">=" " " "_bte_ring_delta(m_screen->row_data)"
, (long double) __n1, ">=", (long double) __n2, 'i'); } while
 (0);

/* The cursor shouldn't be above or below the addressable
 * part of the display buffer. */
              g_assert_cmpint(m_screen->cursor.row, >=, m_screen->insert_delta)do { gint64 __n1 = (m_screen->cursor.row), __n2 = (m_screen
->insert_delta); if (__n1 >= __n2) ; else g_assertion_message_cmpnum
 ("BTE", "../src/bte.cc", 3842, ((const char*) (__PRETTY_FUNCTION__
)), "m_screen->cursor.row" " " ">=" " " "m_screen->insert_delta"
, (long double) __n1, ">=", (long double) __n2, 'i'); } while
 (0);
3843#endif

if (modified) {
/* Keep the cursor on-screen if we scroll on output, or if
 * we're currently at the bottom of the buffer. */
update_insert_delta();
if (m_scroll_on_output || bottom) {
	maybe_scroll_to_bottom();
}
/* Deselect the current selection if its contents are changed
 * by this insertion. */
              if (!m_selection_resolved.empty()) {
                      //FIXMEchpe: this is atrocious
	auto selection = get_selected_text();
	if ((selection == nullptr) ||
	    (m_selection[BTE_SELECTION_PRIMARY] == nullptr) ||
	    (strcmp(selection->str, m_selection[BTE_SELECTION_PRIMARY]->str) != 0)) {
		deselect_all();
	}
                      if (selection)
                              g_string_free(selection, TRUE(!(0)));
}
}

if (modified || (m_screen != previous_screen)) {
              m_ringview.invalidate();
/* Signal that the visible contents changed. */
queue_contents_changed();
}

emit_pending_signals();

if (invalidated_text) {
              invalidate_rows_and_context(bbox_top, bbox_bottom);
}

      if ((saved_cursor.col != m_screen->cursor.col) ||
          (saved_cursor.row != m_screen->cursor.row)) {
/* invalidate the old and new cursor positions */
if (saved_cursor_visible)
                      invalidate_row(saved_cursor.row);
invalidate_cursor_once();
check_cursor_blink();
/* Signal that the cursor moved. */
queue_cursor_moved();
      } else if ((saved_cursor_visible != m_modes_private.DEC_TEXT_CURSOR()) ||
                 (saved_cursor_style != m_cursor_style)) {
              invalidate_row(saved_cursor.row);
check_cursor_blink();
}

/* Tell the input method where the cursor is. */
      im_update_cursor();

      /* After processing some data, do a hyperlink GC. The multiplier is totally arbitrary, feel free to fine tune. */
      _bte_ring_hyperlink_maybe_gc(m_screen->row_data, bytes_processed * 8);

_bte_debug_print (BTE_DEBUG_WORK, ")")do { } while(0);
_bte_debug_print (BTE_DEBUG_IO,do { } while(0)
                        "%" G_GSIZE_FORMAT " bytes in %" G_GSIZE_FORMAT " chunks left to process.\n",do { } while(0)
                        m_input_bytes,do { } while(0)
                        m_incoming_queue.size())do { } while(0);
3905}

3907#endif /* WITH_ICU */

3909bool
3910Terminal::pty_io_read(int const fd,
                    GIOCondition const condition)
3912{
_bte_debug_print (BTE_DEBUG_WORK, ".")do { } while(0);
      _bte_debug_print(BTE_DEBUG_IO, "::pty_io_read condition %02x\n", condition)do { } while(0);

      /* We need to check for EOS so that we can shut down the PTY.
       * When we get G_IO_HUP without G_IO_IN, we can process the EOF now.
       * However when we get G_IO_IN | G_IO_HUP, there is still data to be
       * read in this round, and in potentially more rounds; read the data
       * now, do *not* process the EOS (unless the read returns EIO, which
       * does happen and appears to mean that despite G_IO_IN no data was
       * actually available to be read, not even the cpkt header), and
       * otherwise wait for further calls which will have G_IO_HUP (and
       * possibly G_IO_IN again).
       */
      auto eos = bool{condition == G_IO_HUP};

      /* There is data to read */
auto err = int{0};
      auto again = bool{true};
      bte::base::Chunk* chunk{nullptr};
if (condition & (G_IO_IN | G_IO_PRI)) {
guchar *bp;
int rem, len;
guint bytes, max_bytes;

/* Limit the amount read between updates, so as to
 * 1. maintain fairness between multiple terminals;
 * 2. prevent reading the entire output of a command in one
 *    pass, i.e. we always try to refresh the terminal ~40Hz.
 *    See time_process_incoming() where we estimate the
 *    maximum number of bytes we can read/process in between
 *    updates.
 */
max_bytes = m_active_terminals_link != nullptr ?
            g_list_length(g_active_terminals) - 1 : 0;
if (max_bytes) {
	max_bytes = m_max_input_bytes / max_bytes;
} else {
	max_bytes = m_max_input_bytes;
}
bytes = m_input_bytes;

              /* If possible, try adding more data to the chunk at the back of the queue */
              if (!m_incoming_queue.empty())
                      chunk = m_incoming_queue.back().get();

do {
                      /* No chunk, chunk sealed or at least ¾ full? Get a new chunk */
	if (!chunk ||
                          chunk->sealed() ||
                          chunk->len >= 3 * chunk->capacity() / 4) {
                              m_incoming_queue.push(bte::base::Chunk::get());

                              chunk = m_incoming_queue.back().get();
	}

	rem = chunk->remaining_capacity();
	bp = chunk->data + chunk->len;
	len = 0;
	do {
                              /* We'd like to read (fd, bp, rem); but due to TIOCPKT mode
                               * there's an extra input byte returned at the beginning.
                               * We need to see what that byte is, but otherwise drop it
                               * and write continuously to chunk->data.
                               */
                              char pkt_header;
                              char save = bp[-1];
                              errno(*__errno_location ()) = 0;
                              int ret = read (fd, bp - 1, rem + 1);
                              pkt_header = bp[-1];
                              bp[-1] = save;
		switch (ret){
			case -1:
				err = errno(*__errno_location ());
				goto out;
			case 0:
				eos = true;
				goto out;
			default:
                                              ret--;

                                              if (pkt_header == TIOCPKT_DATA0) {
                                                      bp += ret;
                                                      rem -= ret;
                                                      len += ret;
                                              } else {
                                                      if (pkt_header & TIOCPKT_IOCTL64) {
                                                              /* We'd like to always be informed when the termios change,
                                                               * so we can e.g. detect when no-echo is en/disabled and
                                                               * change the cursor/input method/etc., but unfortunately
                                                               * the kernel only sends this flag when (old or new) 'local flags'
                                                               * include EXTPROC, which is not used often, and due to its side
                                                               * effects, cannot be enabled by bte by default.
                                                               *
                                                               * FIXME: improve the kernel! see discussion in bug 755371
                                                               * starting at comment 12
                                                               */
                                                              pty_termios_changed();
                                                      }
                                                      if (pkt_header & TIOCPKT_STOP4) {
                                                              pty_scroll_lock_changed(true);
                                                      }
                                                      if (pkt_header & TIOCPKT_START8) {
                                                              pty_scroll_lock_changed(false);
                                                      }
                                              }
				break;
		}
	} while (rem);
4021out:
	chunk->len += len;
	bytes += len;
} while (bytes < max_bytes &&
         chunk->len == chunk->capacity());

              /* We may have an empty chunk at the back of the queue, but
               * that doesn't matter, we'll fill it next time.
               */

if (!is_processing()) {
	add_process_timeout(this);
}
m_pty_input_active = len != 0;
m_input_bytes = bytes;
again = bytes < max_bytes;

_bte_debug_print (BTE_DEBUG_IO, "read %d/%d bytes, again? %s, active? %s\n",do { } while(0)
		bytes, max_bytes,do { } while(0)
		again ? "yes" : "no",do { } while(0)
		m_pty_input_active ? "yes" : "no")do { } while(0);
}

      if (condition & G_IO_ERR)
              err = EIO5;

/* Error? */
switch (err) {
      case 0: /* no error */
              break;
      case EIO5: /* EOS */
              eos = true;
              break;
      case EAGAIN11:
      case EBUSY16: /* do nothing */
              break;
      default:
              auto errsv = bte::libc::ErrnoSaver{};
              _bte_debug_print (BTE_DEBUG_IO, "Error reading from child: %s",do { } while(0)
                                g_strerror(errsv))do { } while(0);
              break;
}

      if (eos) {
_bte_debug_print(BTE_DEBUG_IO, "got PTY EOF\n")do { } while(0);

              /* Make a note of the EOS; but do not process it since there may be data
               * to be processed first in the incomding queue.
               */
              if (!chunk || chunk->sealed()) {
                      m_incoming_queue.push(bte::base::Chunk::get());
                      chunk = m_incoming_queue.back().get();
              }

              chunk->set_sealed();
              chunk->set_eos();

              /* Cancel wait timer */
              m_child_exited_eos_wait_timer.abort();

              /* Need to process the EOS */
if (!is_processing()) {
	add_process_timeout(this);
}

              again = false;
      }

return again;
4090}

4092/*
* Terminal::feed:
* @data: data
*
* Interprets @data as if it were data received from a child process.
*/
4098void
4099Terminal::feed(std::string_view const& data,
             bool start_processing_)
4101{
      auto length = data.size();
      auto ptr = data.data();

      bte::base::Chunk* chunk = nullptr;
      if (!m_incoming_queue.empty()) {
              auto& achunk = m_incoming_queue.back();
              if (length < achunk->remaining_capacity() && !achunk->sealed())
                      chunk = achunk.get();
      }
      if (chunk == nullptr) {
              m_incoming_queue.push(bte::base::Chunk::get());
              chunk = m_incoming_queue.back().get();
      }

      /* Break the incoming data into chunks. */
      do {
              auto rem = chunk->remaining_capacity();
              auto len = std::min(length, rem);
              memcpy (chunk->data + chunk->len, ptr, len);
              chunk->len += len;
              length -= len;
              if (length == 0)
                      break;

              ptr += len;

              /* Get another chunk for the remaining data */
              m_incoming_queue.push(bte::base::Chunk::get());
              chunk = m_incoming_queue.back().get();
      } while (true);

      if (start_processing_)
              start_processing();
4135}

4137bool
4138Terminal::pty_io_write(int const fd,
                     GIOCondition const condition)
4140{
      auto const count = write(fd,
                               m_outgoing->data,
                               _bte_byte_array_length(m_outgoing)((m_outgoing)->len));
if (count != -1) {
_BTE_DEBUG_IF (BTE_DEBUG_IO)if (0) {
                      _bte_debug_hexdump("Outgoing buffer written",
                                         (uint8_t const*)m_outgoing->data,
                                         count);
}
_bte_byte_array_consume(m_outgoing, count)g_byte_array_remove_range (m_outgoing, 0, count);
}

      /* Run again if there are more bytes to write */
      return _bte_byte_array_length(m_outgoing)((m_outgoing)->len) != 0;
4155}

4157/* Send some UTF-8 data to the child. */
4158void
4159Terminal::send_child(std::string_view const& data)
4160{
      // FIXMEchpe remove
      if (!m_input_enabled)
              return;

      /* Note that for backward compatibility, we need to emit the
       * ::commit signal even if there is no PTY. See issue bte#222.
       */

      switch (data_syntax()) {
      case DataSyntax::eECMA48_UTF8:
              emit_commit(data);
              if (pty())
                      _bte_byte_array_append(m_outgoing, data.data(), data.size())g_byte_array_append (m_outgoing, (const guint8 *) (data.data(
)), data.size());
              break;

4176#ifdef WITH_ICU
      case DataSyntax::eECMA48_PCTERM: {
              auto converted = m_converter->convert(data);

              emit_commit(converted);
              if (pty())
                      _bte_byte_array_append(m_outgoing, converted.data(), converted.size())g_byte_array_append (m_outgoing, (const guint8 *) (converted.
data()), converted.size());
              break;
      }
4185#endif

      default:
              g_assert_not_reached()do { g_assertion_message_expr ("BTE", "../src/bte.cc", 4188, (
(const char*) (__PRETTY_FUNCTION__)), __null); } while (0);
              return;
      }

      /* If we need to start waiting for the child pty to
       * become available for writing, set that up here. */
      connect_pty_write();
4195}

4197/*
* BteTerminal::feed_child:
* @str: data to send to the child
*
* Sends UTF-8 text to the child as if it were entered by the user
* at the keyboard.
*
* Does nothing if input is disabled.
*/
4206void
4207Terminal::feed_child(std::string_view const& str)
4208{
      if (!m_input_enabled)
              return;

      send_child(str);
4213}

4215/*
* Terminal::feed_child_binary:
* @data: data to send to the child
*
* Sends a block of binary data to the child.
*
* Does nothing if input is disabled.
*/
4223void
4224Terminal::feed_child_binary(std::string_view const& data)
4225{
      if (!m_input_enabled)
              return;

      /* If there's a place for it to go, add the data to the
       * outgoing buffer. */
      if (!pty())
              return;

      emit_commit(data);
      _bte_byte_array_append(m_outgoing, data.data(), data.size())g_byte_array_append (m_outgoing, (const guint8 *) (data.data(
)), data.size());

      /* If we need to start waiting for the child pty to
       * become available for writing, set that up here. */
      connect_pty_write();
4240}

4242void
4243Terminal::send(bte::parser::u8SequenceBuilder const& builder,
                       bool c1,
                       bte::parser::u8SequenceBuilder::Introducer introducer,
                       bte::parser::u8SequenceBuilder::ST st) noexcept
4247{
      std::string str;
      builder.to_string(str, c1, -1, introducer, st);
      feed_child(str);
4251}

4253void
4254Terminal::send(bte::parser::Sequence const& seq,
             bte::parser::u8SequenceBuilder const& builder) noexcept
4256{
      // FIXMEchpe always take c1 & ST from @seq?
      if (seq.type() == BTE_SEQ_OSC &&
          builder.type() == BTE_SEQ_OSC) {
              /* If we reply to a BEL-terminated OSC, reply with BEL-terminated OSC
               * as well, see https://bugzilla.gnome.org/show_bug.cgi?id=722446 and
               * https://gitlab.gnome.org/GNOME/bte/issues/65 .
               */
              send(builder, false,
                   bte::parser::u8SequenceBuilder::Introducer::DEFAULT,
                   seq.terminator() == 0x7 ? bte::parser::u8SequenceBuilder::ST::BEL
                   : bte::parser::u8SequenceBuilder::ST::DEFAULT);
      } else {
              send(builder, false);
      }
4271}

4273void
4274Terminal::send(unsigned int type,
                       std::initializer_list<int> params) noexcept
4276{
      // FIXMEchpe take c1 & ST from @seq
      send(bte::parser::ReplyBuilder{type, params}, false);
4279}

4281void
4282Terminal::reply(bte::parser::Sequence const& seq,
                        unsigned int type,
                        std::initializer_list<int> params) noexcept
4285{
      send(seq, bte::parser::ReplyBuilder{type, params});
4287}

4289#if 0
4290void
4291Terminal::reply(bte::parser::Sequence const& seq,
                        unsigned int type,
                        std::initializer_list<int> params,
                        std::string const& str) noexcept
4295{
      bte::parser::ReplyBuilder reply_builder{type, params};
      reply_builder.set_string(str);
      send(seq, reply_builder);
4299}
4300#endif

4302void
4303Terminal::reply(bte::parser::Sequence const& seq,
                        unsigned int type,
                        std::initializer_list<int> params,
                        bte::parser::ReplyBuilder const& builder) noexcept
4307{
      std::string str;
      builder.to_string(str, true, -1,
                        bte::parser::ReplyBuilder::Introducer::NONE,
                        bte::parser::ReplyBuilder::ST::NONE);

      bte::parser::ReplyBuilder reply_builder{type, params};
      reply_builder.set_string(std::move(str));
      send(seq, reply_builder);
4316}

4318void
4319Terminal::reply(bte::parser::Sequence const& seq,
                        unsigned int type,
                        std::initializer_list<int> params,
                        char const* format,
                        ...) noexcept
4324{
      char buf[128];
      va_list vargs;
      va_start(vargs, format)__builtin_va_start(vargs, format);
      auto len = g_vsnprintf(buf, sizeof(buf), format, vargs);
      va_end(vargs)__builtin_va_end(vargs);
      g_assert_cmpint(len, <, sizeof(buf))do { gint64 __n1 = (len), __n2 = (sizeof(buf)); if (__n1 <
 __n2) ; else g_assertion_message_cmpnum ("BTE", "../src/bte.cc"
, 4330, ((const char*) (__PRETTY_FUNCTION__)), "len" " " "<"
 " " "sizeof(buf)", (long double) __n1, "<", (long double)
 __n2, 'i'); } while (0);

      bte::parser::ReplyBuilder builder{type, params};
      builder.set_string(std::string{buf});

      send(seq, builder);
4336}

4338void
4339Terminal::im_commit(std::string_view const& str)
4340{
      if (!m_input_enabled)
              return;

      _bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                       "Input method committed `%s'.\n", std::string{str}.c_str())do { } while(0);
      send_child(str);

/* Committed text was committed because the user pressed a key, so
* we need to obey the scroll-on-keystroke setting. */
      if (m_scroll_on_keystroke && m_input_enabled) {
maybe_scroll_to_bottom();
}
4353}

4355void
4356Terminal::im_preedit_set_active(bool active) noexcept
4357{
m_im_preedit_active = active;
4359}

4361void
4362Terminal::im_preedit_reset() noexcept
4363{
      m_im_preedit.clear();
      m_im_preedit.shrink_to_fit();
      m_im_preedit_cursor = 0;
      m_im_preedit_attrs.reset();
4368}

4370void
4371Terminal::im_preedit_changed(std::string_view const& str,
                           int cursorpos,
                           pango_attr_list_unique_type&& attrs) noexcept
4374{
/* Queue the area where the current preedit string is being displayed
* for repainting. */
invalidate_cursor_once();

      im_preedit_reset();
m_im_preedit = str;
      m_im_preedit_attrs = std::move(attrs);
      m_im_preedit_cursor = cursorpos;

      /* Invalidate again with the new cursor position */
invalidate_cursor_once();

      /* And tell the input method where the cursor is on the screen */
      im_update_cursor();
4389}

4391bool
4392Terminal::im_retrieve_surrounding()
4393{
      /* FIXME: implement this! Bug #726191 */
      return false;
4396}

4398bool
4399Terminal::im_delete_surrounding(int offset,
                              int n_chars)
4401{
      /* FIXME: implement this! Bug #726191 */
      return false;
4404}

4406void
4407Terminal::im_update_cursor()
4408{
if (!widget_realized())
              return;

      cairo_rectangle_int_t rect;
      rect.x = m_screen->cursor.col * m_cell_width + m_padding.left +
               get_preedit_width(false) * m_cell_width;
      rect.width = m_cell_width; // FIXMEchpe: if columns > 1 ?
      rect.y = row_to_pixel(m_screen->cursor.row) + m_padding.top;
      rect.height = m_cell_height;
      m_real_widget->im_set_cursor_location(&rect);
4419}

4421void
4422Terminal::set_border_padding(CtkBorder const* padding)
4423{
      if (memcmp(padding, &m_padding, sizeof(*padding)) != 0) {
              _bte_debug_print(BTE_DEBUG_MISC | BTE_DEBUG_WIDGET_SIZE,do { } while(0)
                               "Setting padding to (%d,%d,%d,%d)\n",do { } while(0)
                               padding->left, padding->right,do { } while(0)
                               padding->top, padding->bottom)do { } while(0);

              m_padding = *padding;
              update_view_extents();
              ctk_widget_queue_resize(m_widget);
      } else {
              _bte_debug_print(BTE_DEBUG_MISC | BTE_DEBUG_WIDGET_SIZE,do { } while(0)
                               "Keeping padding the same at (%d,%d,%d,%d)\n",do { } while(0)
                               padding->left, padding->right,do { } while(0)
                               padding->top, padding->bottom)do { } while(0);

      }
4440}

4442void
4443Terminal::set_cursor_aspect(float aspect)
4444{
      if (_bte_double_equal(aspect, m_cursor_aspect_ratio))
              return;

      m_cursor_aspect_ratio = aspect;
      invalidate_cursor_once();
4450}

4452void
4453Terminal::widget_style_updated()
4454{
      // FIXMEchpe: remove taking font info from the widget style
      set_font_desc(m_unscaled_font_desc.get());
4457}

4459void
4460Terminal::add_cursor_timeout()
4461{
if (m_cursor_blink_timer)
return; /* already added */

m_cursor_blink_time = 0;
      m_cursor_blink_timer.schedule(m_cursor_blink_cycle, bte::glib::Timer::Priority::eLOW);
4467}

4469void
4470Terminal::remove_cursor_timeout()
4471{
if (!m_cursor_blink_timer)
return; /* already removed */

      m_cursor_blink_timer.abort();
      if (!m_cursor_blink_state) {
              invalidate_cursor_once();
              m_cursor_blink_state = true;
      }
4480}

4482/* Activates / disactivates the cursor blink timer to reduce wakeups */
4483void
4484Terminal::check_cursor_blink()
4485{
if (m_has_focus &&
   m_cursor_blinks &&
   m_modes_private.DEC_TEXT_CURSOR())
add_cursor_timeout();
else
remove_cursor_timeout();
4492}

4494void
4495Terminal::beep()
4496{
if (m_audible_bell)
              m_real_widget->beep();
4499}

4501bool
4502Terminal::widget_key_press(KeyEvent const& event)
4503{
char *normal = NULL__null;
gsize normal_length = 0;
struct termios tio;
gboolean scrolled = FALSE(0), steal = FALSE(0), modifier = FALSE(0), handled,
 suppress_alt_esc = FALSE(0), add_modifiers = FALSE(0);
guint keyval = 0;
gunichar keychar = 0;
char keybuf[BTE_UTF8_BPC(4)];

/* If it's a keypress, record that we got the event, in case the
* input method takes the event from us. */
      // FIXMEchpe this is ::widget_key_press; what other event type could it even be!?
if (event.is_key_press()) {
/* Store a copy of the key. */
              keyval = event.keyval();
              m_modifiers = event.modifiers();

              // FIXMEchpe?
if (m_cursor_blink_timer) {
	remove_cursor_timeout();
	add_cursor_timeout();
}

/* Determine if this is just a modifier key. */
modifier = _bte_keymap_key_is_modifier(keyval);

/* Unless it's a modifier key, hide the pointer. */
if (!modifier) {
                      set_pointer_autohidden(true);
}

_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
		"Keypress, modifiers=0x%x, "do { } while(0)
		"keyval=0x%x, raw string=`%s'.\n",do { } while(0)
		m_modifiers,do { } while(0)
                               keyval, event.string())do { } while(0);

/* We steal many keypad keys here. */
if (!m_im_preedit_active) {
	switch (keyval) {
	case CDK_KEY_KP_Add0xffab:
	case CDK_KEY_KP_Subtract0xffad:
	case CDK_KEY_KP_Multiply0xffaa:
	case CDK_KEY_KP_Divide0xffaf:
	case CDK_KEY_KP_Enter0xff8d:
		steal = TRUE(!(0));
		break;
	default:
		break;
	}
	if (m_modifiers & BTE_ALT_MASKCDK_MOD1_MASK) {
		steal = TRUE(!(0));
	}
	switch (keyval) {
                      case CDK_KEY_ISO_Lock0xfe01:
                      case CDK_KEY_ISO_Level2_Latch0xfe02:
                      case CDK_KEY_ISO_Level3_Shift0xfe03:
                      case CDK_KEY_ISO_Level3_Latch0xfe04:
                      case CDK_KEY_ISO_Level3_Lock0xfe05:
                      case CDK_KEY_ISO_Level5_Shift0xfe11:
                      case CDK_KEY_ISO_Level5_Latch0xfe12:
                      case CDK_KEY_ISO_Level5_Lock0xfe13:
                      case CDK_KEY_ISO_Group_Shift0xff7e:
                      case CDK_KEY_ISO_Group_Latch0xfe06:
                      case CDK_KEY_ISO_Group_Lock0xfe07:
                      case CDK_KEY_ISO_Next_Group0xfe08:
                      case CDK_KEY_ISO_Next_Group_Lock0xfe09:
                      case CDK_KEY_ISO_Prev_Group0xfe0a:
                      case CDK_KEY_ISO_Prev_Group_Lock0xfe0b:
                      case CDK_KEY_ISO_First_Group0xfe0c:
                      case CDK_KEY_ISO_First_Group_Lock0xfe0d:
                      case CDK_KEY_ISO_Last_Group0xfe0e:
                      case CDK_KEY_ISO_Last_Group_Lock0xfe0f:
	case CDK_KEY_Multi_key0xff20:
	case CDK_KEY_Codeinput0xff37:
	case CDK_KEY_SingleCandidate0xff3c:
	case CDK_KEY_MultipleCandidate0xff3d:
	case CDK_KEY_PreviousCandidate0xff3e:
	case CDK_KEY_Kanji0xff21:
	case CDK_KEY_Muhenkan0xff22:
                      case CDK_KEY_Henkan_Mode0xff23:
                      /* case CDK_KEY_Henkan: is CDK_KEY_Henkan_Mode */
	case CDK_KEY_Romaji0xff24:
	case CDK_KEY_Hiragana0xff25:
	case CDK_KEY_Katakana0xff26:
	case CDK_KEY_Hiragana_Katakana0xff27:
	case CDK_KEY_Zenkaku0xff28:
	case CDK_KEY_Hankaku0xff29:
	case CDK_KEY_Zenkaku_Hankaku0xff2a:
	case CDK_KEY_Touroku0xff2b:
	case CDK_KEY_Massyo0xff2c:
	case CDK_KEY_Kana_Lock0xff2d:
	case CDK_KEY_Kana_Shift0xff2e:
	case CDK_KEY_Eisu_Shift0xff2f:
	case CDK_KEY_Eisu_toggle0xff30:
                      /* case CDK_KEY_Kanji_Bangou: is CDK_KEY_Codeinput */
                      /* case CDK_KEY_Zen_Koho: is CDK_KEY_MultipleCandidate */
                      /* case CDK_KEY_Mae_Koho: is CDK_KEY_PreviousCandidate */
                      /* case CDK_KEY_kana_switch: is CDK_KEY_ISO_Group_Shift */
                      case CDK_KEY_Hangul0xff31:
                      case CDK_KEY_Hangul_Start0xff32:
                      case CDK_KEY_Hangul_End0xff33:
                      case CDK_KEY_Hangul_Hanja0xff34:
                      case CDK_KEY_Hangul_Jamo0xff35:
                      case CDK_KEY_Hangul_Romaja0xff36:
                      /* case CDK_KEY_Hangul_Codeinput: is CDK_KEY_Codeinput */
                      case CDK_KEY_Hangul_Jeonja0xff38:
                      case CDK_KEY_Hangul_Banja0xff39:
                      case CDK_KEY_Hangul_PreHanja0xff3a:
                      case CDK_KEY_Hangul_PostHanja0xff3b:
                      /* case CDK_KEY_Hangul_SingleCandidate: is CDK_KEY_SingleCandidate */
                      /* case CDK_KEY_Hangul_MultipleCandidate: is CDK_KEY_MultipleCandidate */
                      /* case CDK_KEY_Hangul_PreviousCandidate: is CDK_KEY_PreviousCandidate */
                      case CDK_KEY_Hangul_Special0xff3f:
                      /* case CDK_KEY_Hangul_switch: is CDK_KEY_ISO_Group_Shift */

		steal = FALSE(0);
		break;
	default:
		break;
	}
}
}

/* Let the input method at this one first. */
if (!steal && m_input_enabled) {
              if (m_real_widget->im_filter_keypress(event)) {
	_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
			"Keypress taken by IM.\n")do { } while(0);
	return true;
}
}

/* Now figure out what to send to the child. */
if (event.is_key_press() && !modifier) {
handled = FALSE(0);
/* Map the key to a sequence name if we can. */
switch (event.keyval()) {
case CDK_KEY_BackSpace0xff08:
	switch (m_backspace_binding) {
	case EraseMode::eASCII_BACKSPACE:
		normal = g_strdup("")g_strdup_inline ("");
		normal_length = 1;
		suppress_alt_esc = FALSE(0);
		break;
	case EraseMode::eASCII_DELETE:
		normal = g_strdup("")g_strdup_inline ("");
		normal_length = 1;
		suppress_alt_esc = FALSE(0);
		break;
	case EraseMode::eDELETE_SEQUENCE:
                              normal = g_strdup("\e[3~")g_strdup_inline ("\e[3~");
                              normal_length = 4;
                              add_modifiers = TRUE(!(0));
		suppress_alt_esc = TRUE(!(0));
		break;
	case EraseMode::eTTY:
		if (pty() &&
		    tcgetattr(pty()->fd(), &tio) != -1)
		{
			normal = g_strdup_printf("%c", tio.c_cc[VERASE2]);
			normal_length = 1;
		}
		suppress_alt_esc = FALSE(0);
		break;
	case EraseMode::eAUTO:
	default:
4671#ifndef _POSIX_VDISABLE'\0'
4672#define _POSIX_VDISABLE'\0' '\0'
4673#endif
		if (pty() &&
		    tcgetattr(pty()->fd(), &tio) != -1 &&
		    tio.c_cc[VERASE2] != _POSIX_VDISABLE'\0')
		{
			normal = g_strdup_printf("%c", tio.c_cc[VERASE2]);
			normal_length = 1;
		}
		else
		{
			normal = g_strdup("")g_strdup_inline ("");
			normal_length = 1;
			suppress_alt_esc = FALSE(0);
		}
		suppress_alt_esc = FALSE(0);
		break;
	}
                      /* Toggle ^H vs ^? if Ctrl is pressed */
                      if (normal_length == 1 && m_modifiers & CDK_CONTROL_MASK) {
                              if (normal[0] == '\010')
                                      normal[0] = '\177';
                              else if (normal[0] == '\177')
                                      normal[0] = '\010';
                      }
	handled = TRUE(!(0));
	break;
case CDK_KEY_KP_Delete0xff9f:
case CDK_KEY_Delete0xffff:
	switch (m_delete_binding) {
	case EraseMode::eASCII_BACKSPACE:
		normal = g_strdup("\010")g_strdup_inline ("\010");
		normal_length = 1;
		break;
	case EraseMode::eASCII_DELETE:
		normal = g_strdup("\177")g_strdup_inline ("\177");
		normal_length = 1;
		break;
	case EraseMode::eTTY:
		if (pty() &&
		    tcgetattr(pty()->fd(), &tio) != -1)
		{
			normal = g_strdup_printf("%c", tio.c_cc[VERASE2]);
			normal_length = 1;
		}
		suppress_alt_esc = FALSE(0);
		break;
	case EraseMode::eDELETE_SEQUENCE:
	case EraseMode::eAUTO:
	default:
                              normal = g_strdup("\e[3~")g_strdup_inline ("\e[3~");
                              normal_length = 4;
                              add_modifiers = TRUE(!(0));
		break;
	}
	handled = TRUE(!(0));
                      /* FIXMEchpe: why? this overrides the FALSE set above? */
	suppress_alt_esc = TRUE(!(0));
	break;
case CDK_KEY_KP_Insert0xff9e:
case CDK_KEY_Insert0xff63:
	if (m_modifiers & CDK_SHIFT_MASK) {
		if (m_modifiers & CDK_CONTROL_MASK) {
                                      emit_paste_clipboard();
			handled = TRUE(!(0));
			suppress_alt_esc = TRUE(!(0));
		} else {
                                      widget_paste(CDK_SELECTION_PRIMARY((CdkAtom)((gpointer) (gulong) (1))));
			handled = TRUE(!(0));
			suppress_alt_esc = TRUE(!(0));
		}
	} else if (m_modifiers & CDK_CONTROL_MASK) {
                              emit_copy_clipboard();
		handled = TRUE(!(0));
		suppress_alt_esc = TRUE(!(0));
	}
	break;
/* Keypad/motion keys. */
case CDK_KEY_KP_Up0xff97:
case CDK_KEY_Up0xff52:
	if (m_screen == &m_normal_screen &&
	    m_modifiers & CDK_CONTROL_MASK &&
                          m_modifiers & CDK_SHIFT_MASK) {
		scroll_lines(-1);
		scrolled = TRUE(!(0));
		handled = TRUE(!(0));
		suppress_alt_esc = TRUE(!(0));
	}
	break;
case CDK_KEY_KP_Down0xff99:
case CDK_KEY_Down0xff54:
	if (m_screen == &m_normal_screen &&
	    m_modifiers & CDK_CONTROL_MASK &&
                          m_modifiers & CDK_SHIFT_MASK) {
		scroll_lines(1);
		scrolled = TRUE(!(0));
		handled = TRUE(!(0));
		suppress_alt_esc = TRUE(!(0));
	}
	break;
case CDK_KEY_KP_Page_Up0xff9a:
case CDK_KEY_Page_Up0xff55:
	if (m_screen == &m_normal_screen &&
	    m_modifiers & CDK_SHIFT_MASK) {
		scroll_pages(-1);
		scrolled = TRUE(!(0));
		handled = TRUE(!(0));
		suppress_alt_esc = TRUE(!(0));
	}
	break;
case CDK_KEY_KP_Page_Down0xff9b:
case CDK_KEY_Page_Down0xff56:
	if (m_screen == &m_normal_screen &&
	    m_modifiers & CDK_SHIFT_MASK) {
		scroll_pages(1);
		scrolled = TRUE(!(0));
		handled = TRUE(!(0));
		suppress_alt_esc = TRUE(!(0));
	}
	break;
case CDK_KEY_KP_Home0xff95:
case CDK_KEY_Home0xff50:
	if (m_screen == &m_normal_screen &&
	    m_modifiers & CDK_SHIFT_MASK) {
		maybe_scroll_to_top();
		scrolled = TRUE(!(0));
		handled = TRUE(!(0));
	}
	break;
case CDK_KEY_KP_End0xff9c:
case CDK_KEY_End0xff57:
	if (m_screen == &m_normal_screen &&
	    m_modifiers & CDK_SHIFT_MASK) {
		maybe_scroll_to_bottom();
		scrolled = TRUE(!(0));
		handled = TRUE(!(0));
	}
	break;
/* Let Shift +/- tweak the font, like XTerm does. */
case CDK_KEY_KP_Add0xffab:
case CDK_KEY_KP_Subtract0xffad:
	if (m_modifiers & (CDK_SHIFT_MASK | CDK_CONTROL_MASK)) {
		switch (keyval) {
		case CDK_KEY_KP_Add0xffab:
			emit_increase_font_size();
			handled = TRUE(!(0));
			suppress_alt_esc = TRUE(!(0));
			break;
		case CDK_KEY_KP_Subtract0xffad:
			emit_decrease_font_size();
			handled = TRUE(!(0));
			suppress_alt_esc = TRUE(!(0));
			break;
		}
	}
	break;
default:
	break;
}
/* If the above switch statement didn't do the job, try mapping
 * it to a literal or capability name. */
              if (handled == FALSE(0)) {
                      if (G_UNLIKELY (m_enable_bidi &&(__builtin_expect (__extension__ ({ int _g_boolean_var_1003; if
 (m_enable_bidi && m_modes_private.BTE_BIDI_SWAP_ARROW_KEYS
() && (keyval == 0xff51 || keyval == 0xff53 || keyval
 == 0xff96 || keyval == 0xff98)) _g_boolean_var_1003 = 1; else
 _g_boolean_var_1003 = 0; _g_boolean_var_1003; }), 0))
                                      m_modes_private.BTE_BIDI_SWAP_ARROW_KEYS() &&(__builtin_expect (__extension__ ({ int _g_boolean_var_1003; if
 (m_enable_bidi && m_modes_private.BTE_BIDI_SWAP_ARROW_KEYS
() && (keyval == 0xff51 || keyval == 0xff53 || keyval
 == 0xff96 || keyval == 0xff98)) _g_boolean_var_1003 = 1; else
 _g_boolean_var_1003 = 0; _g_boolean_var_1003; }), 0))
                                      (keyval == CDK_KEY_Left ||(__builtin_expect (__extension__ ({ int _g_boolean_var_1003; if
 (m_enable_bidi && m_modes_private.BTE_BIDI_SWAP_ARROW_KEYS
() && (keyval == 0xff51 || keyval == 0xff53 || keyval
 == 0xff96 || keyval == 0xff98)) _g_boolean_var_1003 = 1; else
 _g_boolean_var_1003 = 0; _g_boolean_var_1003; }), 0))
                                       keyval == CDK_KEY_Right ||(__builtin_expect (__extension__ ({ int _g_boolean_var_1003; if
 (m_enable_bidi && m_modes_private.BTE_BIDI_SWAP_ARROW_KEYS
() && (keyval == 0xff51 || keyval == 0xff53 || keyval
 == 0xff96 || keyval == 0xff98)) _g_boolean_var_1003 = 1; else
 _g_boolean_var_1003 = 0; _g_boolean_var_1003; }), 0))
                                       keyval == CDK_KEY_KP_Left ||(__builtin_expect (__extension__ ({ int _g_boolean_var_1003; if
 (m_enable_bidi && m_modes_private.BTE_BIDI_SWAP_ARROW_KEYS
() && (keyval == 0xff51 || keyval == 0xff53 || keyval
 == 0xff96 || keyval == 0xff98)) _g_boolean_var_1003 = 1; else
 _g_boolean_var_1003 = 0; _g_boolean_var_1003; }), 0))
                                       keyval == CDK_KEY_KP_Right))(__builtin_expect (__extension__ ({ int _g_boolean_var_1003; if
 (m_enable_bidi && m_modes_private.BTE_BIDI_SWAP_ARROW_KEYS
() && (keyval == 0xff51 || keyval == 0xff53 || keyval
 == 0xff96 || keyval == 0xff98)) _g_boolean_var_1003 = 1; else
 _g_boolean_var_1003 = 0; _g_boolean_var_1003; }), 0))) {
                              /* In keyboard arrow swapping mode, the left and right arrows need swapping
                               * if the cursor stands inside a (possibly autodetected) RTL paragraph. */
                              ensure_row();
                              BteRowData const *row_data = find_row_data(m_screen->cursor.row);
                              bool rtl;
                              if ((row_data->attr.bidi_flags & (BTE_BIDI_FLAG_IMPLICIT | BTE_BIDI_FLAG_AUTO))
                                                            == (BTE_BIDI_FLAG_IMPLICIT | BTE_BIDI_FLAG_AUTO)) {
                                      /* Implicit paragraph with autodetection. Need to run the BiDi algorithm
                                       * to get the autodetected direction.
                                       * m_ringview is for the onscreen contents and the cursor may be offscreen.
                                       * Better leave that alone and use a temporary ringview for the cursor's row. */
                                      bte::base::RingView ringview;
                                      ringview.set_ring(m_screen->row_data);
                                      ringview.set_rows(m_screen->cursor.row, 1);
                                      ringview.set_width(m_column_count);
                                      ringview.update();
                                      rtl = ringview.get_bidirow(m_screen->cursor.row)->base_is_rtl();
                              } else {
                                      /* Not an implicit paragraph with autodetection, no autodetection
                                       * is required. Take the direction straight from the stored data. */
                                      rtl = !!(row_data->attr.bidi_flags & BTE_BIDI_FLAG_RTL);
                              }
                              if (rtl) {
                                      switch (keyval) {
                                      case CDK_KEY_Left0xff51:
                                              keyval = CDK_KEY_Right0xff53;
                                              break;
                                      case CDK_KEY_Right0xff53:
                                              keyval = CDK_KEY_Left0xff51;
                                              break;
                                      case CDK_KEY_KP_Left0xff96:
                                              keyval = CDK_KEY_KP_Right0xff98;
                                              break;
                                      case CDK_KEY_KP_Right0xff98:
                                              keyval = CDK_KEY_KP_Left0xff96;
                                              break;
                                      }
                              }
                      }

	_bte_keymap_map(keyval, m_modifiers,
                                      m_modes_private.DEC_APPLICATION_CURSOR_KEYS(),
                                      m_modes_private.DEC_APPLICATION_KEYPAD(),
			&normal,
			&normal_length);
	/* If we found something this way, suppress
	 * escape-on-alt. */
                      if (normal != NULL__null && normal_length > 0) {
		suppress_alt_esc = TRUE(!(0));
	}
}

/* Shall we do this here or earlier?  See bug 375112 and bug 589557 */
if (m_modifiers & CDK_CONTROL_MASK && widget())
                      keyval = widget()->key_event_translate_ctrlkey(event);

/* If we didn't manage to do anything, try to salvage a
 * printable string. */
if (handled == FALSE(0) && normal == NULL__null) {

	/* Convert the keyval to a gunichar. */
	keychar = cdk_keyval_to_unicode(keyval);
	normal_length = 0;
	if (keychar != 0) {
		/* Convert the gunichar to a string. */
		normal_length = g_unichar_to_utf8(keychar,
						  keybuf);
		if (normal_length != 0) {
			normal = (char *)g_malloc(normal_length + 1);
			memcpy(normal, keybuf, normal_length);
			normal[normal_length] = '\0';
		} else {
			normal = NULL__null;
		}
	}
	if ((normal != NULL__null) &&
	    (m_modifiers & CDK_CONTROL_MASK)) {
		/* Replace characters which have "control"
		 * counterparts with those counterparts. */
		for (size_t i = 0; i < normal_length; i++) {
			if ((((guint8)normal[i]) >= 0x40) &&
			    (((guint8)normal[i]) <  0x80)) {
				normal[i] &= (~(0x60));
			}
		}
	}
	_BTE_DEBUG_IF (BTE_DEBUG_EVENTS)if (0) {
		if (normal) g_printerr(
				"Keypress, modifiers=0x%x, "
				"keyval=0x%x, cooked string=`%s'.\n",
				m_modifiers,
				keyval, normal);
	}
}
/* If we got normal characters, send them to the child. */
if (normal != NULL__null) {
                      if (add_modifiers) {
                              _bte_keymap_key_add_key_modifiers(keyval,
                                                                m_modifiers,
                                                                m_modes_private.DEC_APPLICATION_CURSOR_KEYS(),
                                                                &normal,
                                                                &normal_length);
                      }
	if (m_modes_private.XTERM_META_SENDS_ESCAPE() &&
	    !suppress_alt_esc &&
	    (normal_length > 0) &&
	    (m_modifiers & BTE_ALT_MASKCDK_MOD1_MASK)) {
		feed_child(_BTE_CAP_ESC"\033", 1);
	}
	if (normal_length > 0) {
		send_child({normal, normal_length});
	}
	g_free(normal);
}
/* Keep the cursor on-screen. */
if (!scrolled && !modifier &&
                  m_scroll_on_keystroke && m_input_enabled) {
	maybe_scroll_to_bottom();
}
return true;
}
return false;
4962}

4964bool
4965Terminal::widget_key_release(KeyEvent const& event)
4966{
      m_modifiers = event.modifiers();

if (m_input_enabled &&
          m_real_widget->im_filter_keypress(event))
              return true;

      return false;
4974}

4976static const guint8 word_char_by_category[] = {
      [G_UNICODE_CONTROL]             = 2,
      [G_UNICODE_FORMAT]              = 2,
      [G_UNICODE_UNASSIGNED]          = 2,
      [G_UNICODE_PRIVATE_USE]         = 0,
      [G_UNICODE_SURROGATE]           = 2,
      [G_UNICODE_LOWERCASE_LETTER]    = 1,
      [G_UNICODE_MODIFIER_LETTER]     = 1,
      [G_UNICODE_OTHER_LETTER]        = 1,
      [G_UNICODE_TITLECASE_LETTER]    = 1,
      [G_UNICODE_UPPERCASE_LETTER]    = 1,
      [G_UNICODE_SPACING_MARK]        = 0,
      [G_UNICODE_ENCLOSING_MARK]      = 0,
      [G_UNICODE_NON_SPACING_MARK]    = 0,
      [G_UNICODE_DECIMAL_NUMBER]      = 1,
      [G_UNICODE_LETTER_NUMBER]       = 1,
      [G_UNICODE_OTHER_NUMBER]        = 1,
      [G_UNICODE_CONNECT_PUNCTUATION] = 0,
      [G_UNICODE_DASH_PUNCTUATION]    = 0,
      [G_UNICODE_CLOSE_PUNCTUATION]   = 0,
      [G_UNICODE_FINAL_PUNCTUATION]   = 0,
      [G_UNICODE_INITIAL_PUNCTUATION] = 0,
      [G_UNICODE_OTHER_PUNCTUATION]   = 0,
      [G_UNICODE_OPEN_PUNCTUATION]    = 0,
      [G_UNICODE_CURRENCY_SYMBOL]     = 0,
      [G_UNICODE_MODIFIER_SYMBOL]     = 0,
      [G_UNICODE_MATH_SYMBOL]         = 0,
      [G_UNICODE_OTHER_SYMBOL]        = 0,
      [G_UNICODE_LINE_SEPARATOR]      = 2,
      [G_UNICODE_PARAGRAPH_SEPARATOR] = 2,
      [G_UNICODE_SPACE_SEPARATOR]     = 2,
5007};

5009/*
* Terminal::is_word_char:
* @c: a candidate Unicode code point
*
* Checks if a particular character is considered to be part of a word or not.
*
* Returns: %TRUE if the character is considered to be part of a word
*/
5017bool
5018Terminal::is_word_char(gunichar c) const
5019{
      const guint8 v = word_char_by_category[g_unichar_type(c)];

      if (v)
              return v == 1;

      /* Do we have an exception? */
      return std::find(std::begin(m_word_char_exceptions), std::end(m_word_char_exceptions), char32_t(c)) != std::end(m_word_char_exceptions);
5027}

5029/* Check if the characters in the two given locations are in the same class
* (word vs. non-word characters).
* Note that calling this method may invalidate the return value of
* a previous find_row_data() call. */
5033bool
5034Terminal::is_same_class(bte::grid::column_t acol,
                                bte::grid::row_t arow,
                                bte::grid::column_t bcol,
                                bte::grid::row_t brow) const
5038{
BteCell const* pcell = nullptr;
bool word_char;
if ((pcell = find_charcell(acol, arow)) != nullptr && pcell->c != 0) {
              /* Group together if they're fragments of the very same character (not just character value) */
              if (arow == brow) {
                      auto a2 = acol, b2 = bcol;
                      while (a2 > 0 && find_charcell(a2, arow)->attr.fragment()) a2--;
                      while (b2 > 0 && find_charcell(b2, brow)->attr.fragment()) b2--;
                      if (a2 == b2)
                              return true;
              }

word_char = is_word_char(_bte_unistr_get_base(pcell->c));

/* Lets not group non-wordchars together (bug #25290) */
if (!word_char)
	return false;

pcell = find_charcell(bcol, brow);
if (pcell == NULL__null || pcell->c == 0) {
	return false;
}
if (word_char != is_word_char(_bte_unistr_get_base(pcell->c))) {
	return false;
}
return true;
}
return false;
5067}

5069/*
* Convert the mouse click or drag location (left or right half of a cell) into a selection endpoint
* (a boundary between characters), extending the selection according to the current mode, in the
* direction given in the @after parameter.
*
* All four selection modes require different strategies.
*
* In char mode, what matters is which vertical character boundary is closer, taking multi-cell characters
* (CJKs, TABs) into account. Given the string "abcdef", if the user clicks on the boundary between "a"
* and "b" (perhaps on the right half of "a", perhaps on the left half of "b"), and moves the mouse to the
* boundary between "e" and "f" (perhaps a bit over "e", perhaps a bit over "f"), the selection should be
* "bcde". By dragging the mouse back to approximately the click location, it is possible to select the
* empty string. This is the common sense behavior impemented by basically every graphical toolkit
* (unfortunately not by many terminal emulators), and also the one we go for.
*
* Word mode is the trickiest one. Many implementations have weird corner case bugs (e.g. don't highlight
* a word if you double click on the second half of its last letter, or even highlight it if you click on
* the first half of the following space). I think it is expected that double-clicking anywhere over a
* word (including the first half of its first letter, or the last half of its last letter), but over no
* other character, selects this entire word. By dragging the mouse it's not possible to select nothing,
* the word (or non-word character) initially clicked on is always part of the selection. (An exception
* is when clicking occurred over the margin, or an unused cell in a soft-wrapped row (due to CJK
* wrapping).) Also, for symmetry reasons, the word (or non-word character) under the current mouse
* location is also always selected.
*
* Line (paragraph) mode is conceptually quite similar to word mode (the cell, thus the entire row under
* the click's location is always included), but is much easier to implement.
*
* In block mode, similarly to char mode, we care about vertical character boundary. (This is somewhat
* debatable, as results in asymmetrical behavior along the two axes: a rectangle can disappear by
* becoming zero wide, but not zero high.) We cannot take care of CJKs at the endpoints now because CJKs
* can cross the boundary in any included row. Taking care of them needs to go to cell_is_selected_*().
* We don't care about used vs. unused cells either. The event coordinate is simply rounded to the
* nearest vertical cell boundary.
*/
5104bte::grid::coords
5105Terminal::resolve_selection_endpoint(bte::grid::halfcoords const& rowcolhalf, bool after) const
5106{
      auto row = rowcolhalf.row();
      auto col = rowcolhalf.halfcolumn().column();  /* Points to an actual cell now. At the end of this
                                                       method it'll point to a boundary. */
      auto half = rowcolhalf.halfcolumn().half();  /* 0 for left half, 1 for right half of the cell. */
      BteRowData const* rowdata;
      BteCell const* cell;
      int len;

      if (m_selection_block_mode) {
              /* Just find the nearest cell boundary within the line, not caring about CJKs, unused
               * cells, or wrapping at EOL. The @after parameter is unused in this mode. */
              col += half;
              col = std::clamp (col, 0L, m_column_count);
      } else {
              switch (m_selection_type) {
              case SelectionType::eCHAR:
                      /* Find the nearest actual character boundary, taking CJKs and TABs into account.
                       * If at least halfway through the first unused cell, or over the right margin
                       * then wrap to the beginning of the next line.
                       * The @after parameter is unused in this mode. */
                      if (col < 0) {
                              col = 0;
                      } else if (col >= m_column_count) {
                              /* If on the right padding, select the entire line including a possible
                               * newline character. This way if a line is fully filled and ends in a
                               * newline, there's only a half cell width for which the line is selected
                               * without the newline, but at least there's a way to include the newline
                               * by moving the mouse to the right (bug 724253). */
                              col = 0;
                              row++;
                      } else {
                              bte::grid::column_t char_begin, char_end;  /* cell boundaries */
                              rowdata = find_row_data(row);
                              if (rowdata && col < _bte_row_data_nonempty_length(rowdata)) {
                                      /* Clicked over a used cell. Check for multi-cell characters. */
                                      char_begin = col;
                                      while (char_begin > 0) {
                                              cell = _bte_row_data_get (rowdata, char_begin);
                                              if (!cell->attr.fragment())
                                                      break;
                                              char_begin--;
                                      }
                                      cell = _bte_row_data_get (rowdata, char_begin);
                                      char_end = char_begin + cell->attr.columns();
                              } else {
                                      /* Clicked over unused area. Just go with cell boundaries. */
                                      char_begin = col;
                                      char_end = char_begin + 1;
                              }
                              /* Which boundary is closer? */
                              if (col * 2 + half < char_begin + char_end)
                                      col = char_begin;
                              else
                                      col = char_end;

                              /* Maybe wrap to the beginning of the next line. */
                              if (col > (rowdata ? _bte_row_data_nonempty_length(rowdata) : 0)) {
                                      col = 0;
                                      row++;
                              }
                      }
                      break;

              case SelectionType::eWORD:
                      /* Initialization for the cumbersome cases where the click didn't occur over an actual used cell. */
                      rowdata = find_row_data(row);
                      if (col < 0) {
                              /* Clicked over the left margin.
                               * - If within a word (that is, the first letter in this row, and the last
                               *   letter of the previous row belong to the same word) then select the
                               *   letter according to the direction and continue expanding.
                               * - Otherwise stop, the boundary is here before the first letter. */
                              if (row > 0 &&
                                  (rowdata = find_row_data(row - 1)) != nullptr &&
                                  rowdata->attr.soft_wrapped &&
                                  (len = _bte_row_data_nonempty_length(rowdata)) > 0 &&
                                  is_same_class(len - 1, row - 1, 0, row) /* invalidates rowdata! */) {
                                      if (!after) {
                                              col = len - 1;
                                              row--;
                                      } else {
                                              col = 0;
                                      }
                                      /* go on with expanding */
                              } else {
                                      col = 0;  /* end-exclusive */
                                      break;  /* done, don't expand any more */
                              }
                      } else if (col >= (rowdata ? _bte_row_data_nonempty_length(rowdata) : 0)) {
                              /* Clicked over the right margin, or right unused area.
                               * - If within a word (that is, the last letter in this row, and the first
                               *   letter of the next row belong to the same word) then select the letter
                               *   according to the direction and continue expanding.
                               * - Otherwise, if the row is soft-wrapped and we're over the unused area
                               *   (which can happen if a CJK wrapped) or over the right margin, then
                               *   stop, the boundary is wrapped to the beginning of the next row.
                               * - Otherwise select the newline only and stop. */
                              if (rowdata != nullptr &&
                                  rowdata->attr.soft_wrapped) {
                                      if ((len = _bte_row_data_nonempty_length(rowdata)) > 0 &&
                                          is_same_class(len - 1, row, 0, row + 1) /* invalidates rowdata! */) {
                                              if (!after) {
                                                      col = len - 1;
                                              } else {
                                                      col = 0;
                                                      row++;
                                              }
                                              /* go on with expanding */
                                      } else {
                                              col = 0;  /* end-exclusive */
                                              row++;
                                              break;  /* done, don't expand any more */
                                      }
                              } else {
                                      if (!after) {
                                              col = rowdata ? _bte_row_data_nonempty_length(rowdata) : 0;  /* end-exclusive */
                                      } else {
                                              col = 0;  /* end-exclusive */
                                              row++;
                                      }
                                      break;  /* done, don't expand any more */
                              }
                      }

                      /* Expand in the given direction. */
                      if (!after) {
                              /* Keep selecting to the left (and then up) as long as the next character
                               * we look at is of the same class as the current start point. */
                              while (true) {
                                      /* Back up within the row. */
                                      for (; col > 0; col--) {
                                              if (!is_same_class(col - 1, row, col, row)) {
                                                      break;
                                              }
                                      }
                                      if (col > 0) {
                                              /* We hit a stopping point, so stop. */
                                              break;
                                      }
                                      if (row == 0) {
                                              /* At the very beginning. */
                                              break;
                                      }
                                      rowdata = find_row_data(row - 1);
                                      if (!rowdata || !rowdata->attr.soft_wrapped) {
                                              /* Reached a hard newline. */
                                              break;
                                      }
                                      len = _bte_row_data_nonempty_length(rowdata);
                                      /* len might be smaller than m_column_count if a CJK wrapped */
                                      if (!is_same_class(len - 1, row - 1, col, row) /* invalidates rowdata! */) {
                                              break;
                                      }
                                      /* Move on to the previous line. */
                                      col = len - 1;
                                      row--;
                              }
                      } else {
                              /* Keep selecting to the right (and then down) as long as the next character
                               * we look at is of the same class as the current end point. */
                              while (true) {
                                      rowdata = find_row_data(row);
                                      if (!rowdata) {
                                              break;
                                      }
                                      len = _bte_row_data_nonempty_length(rowdata);
                                      bool soft_wrapped = rowdata->attr.soft_wrapped;
                                      /* Move forward within the row. */
                                      for (; col < len - 1; col++) {
                                              if (!is_same_class(col, row, col + 1, row) /* invalidates rowdata! */) {
                                                      break;
                                              }
                                      }
                                      if (col < len - 1) {
                                              /* We hit a stopping point, so stop. */
                                              break;
                                      }
                                      if (!soft_wrapped) {
                                              /* Reached a hard newline. */
                                              break;
                                      }
                                      if (!is_same_class(col, row, 0, row + 1)) {
                                              break;
                                      }
                                      /* Move on to the next line. */
                                      col = 0;
                                      row++;
                              }
                              col++;  /* col points to an actual cell, we need end-exclusive instead. */
                      }
                      break;

              case SelectionType::eLINE:
                      if (!after) {
                              /* Back up as far as we can go. */
                              while (row > 0 &&
                                     _bte_ring_contains (m_screen->row_data, row - 1) &&
                                     m_screen->row_data->is_soft_wrapped(row - 1)) {
                                      row--;
                              }
                      } else {
                              /* Move forward as far as we can go. */
                              while (_bte_ring_contains (m_screen->row_data, row) &&
                                     m_screen->row_data->is_soft_wrapped(row)) {
                                      row++;
                              }
                              row++;  /* One more row, since the column is 0. */
                      }
                      col = 0;
                      break;
              }
      }

      return { row, col };
5321}

5323/*
* Creates the selection's span from the origin and last coordinates.
*
* The origin and last points might be in reverse order; in block mode they might even point to the
* two other corners of the rectangle than the ones we're interested in.
* The resolved span will contain the endpoints in the proper order.
*
* In word & line (paragraph) modes it extends the selection accordingly.
*
* Also makes sure to invalidate the regions that changed, and update m_selecting_had_delta.
*
* FIXMEegmont it always resolves both endpoints. With a bit of extra bookkeeping it could usually
* just resolve the moving one.
*/
5337void
5338Terminal::resolve_selection()
5339{
      if (m_selection_origin.row() < 0 || m_selection_last.row() < 0) {
              invalidate (m_selection_resolved);
              m_selection_resolved.clear();
              _bte_debug_print(BTE_DEBUG_SELECTION, "Selection resolved to %s.\n", m_selection_resolved.to_string())do { } while(0);
              return;
      }

      auto m_selection_resolved_old = m_selection_resolved;

      if (m_selection_block_mode) {
              auto top    = std::min (m_selection_origin.row(), m_selection_last.row());
              auto bottom = std::max (m_selection_origin.row(), m_selection_last.row());
              auto left   = std::min (m_selection_origin.halfcolumn(), m_selection_last.halfcolumn());
              auto right  = std::max (m_selection_origin.halfcolumn(), m_selection_last.halfcolumn());

              auto topleft     = resolve_selection_endpoint ({ top,    left  }, false);
              auto bottomright = resolve_selection_endpoint ({ bottom, right }, true);

              if (topleft.column() == bottomright.column()) {
                      m_selection_resolved.clear();
              } else {
                      m_selection_resolved.set (topleft, bottomright);
              }
      } else {
              auto start = std::min (m_selection_origin, m_selection_last);
              auto end   = std::max (m_selection_origin, m_selection_last);

              m_selection_resolved.set (resolve_selection_endpoint (start, false),
                                        resolve_selection_endpoint (end,   true));
      }

      if (!m_selection_resolved.empty())
              m_selecting_had_delta = true;

      _bte_debug_print(BTE_DEBUG_SELECTION, "Selection resolved to %s.\n", m_selection_resolved.to_string())do { } while(0);

      invalidate_symmetrical_difference (m_selection_resolved_old, m_selection_resolved, m_selection_block_mode);
5377}

5379void
5380Terminal::modify_selection (bte::view::coords const& pos)
5381{
      g_assert (m_selecting)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1004
; if (m_selecting) _g_boolean_var_1004 = 1; else _g_boolean_var_1004
 = 0; _g_boolean_var_1004; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 5382, ((const char*) (__PRETTY_FUNCTION__
)), "m_selecting"); } while (0);

      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto current = selection_grid_halfcoords_from_view_coords (pos);

      if (current == m_selection_last)
              return;

      _bte_debug_print(BTE_DEBUG_SELECTION,do { } while(0)
                       "Selection dragged to %s.\n",do { } while(0)
                       current.to_string())do { } while(0);

      m_selection_last = current;
      resolve_selection();
5398}

5400/* Check if a cell is selected or not. BiDi: the coordinate is logical. */
5401bool
5402Terminal::cell_is_selected_log(bte::grid::column_t lcol,
                             bte::grid::row_t row) const
5404{
      /* Our caller had to update the ringview (we can't do because we're const). */
      g_assert(m_ringview.is_updated())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1005
; if (m_ringview.is_updated()) _g_boolean_var_1005 = 1; else _g_boolean_var_1005
 = 0; _g_boolean_var_1005; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 5406, ((const char*) (__PRETTY_FUNCTION__
)), "m_ringview.is_updated()"); } while (0);

      if (m_selection_block_mode) {
              /* In block mode, make sure CJKs and TABs aren't cut in half. */
              while (lcol > 0) {
                      BteCell const* cell = find_charcell(lcol, row);
                      if (!cell || !cell->attr.fragment())
                              break;
                      lcol--;
              }
              /* Convert to visual. */
              bte::base::BidiRow const* bidirow = m_ringview.get_bidirow(row);
              bte::grid::column_t vcol = bidirow->log2vis(lcol);
              return m_selection_resolved.box_contains ({ row, vcol });
      } else {
              /* In normal modes, resolve_selection() made sure to generate such boundaries for m_selection_resolved. */
              return m_selection_resolved.contains ({ row, lcol });
      }
5424}

5426/* Check if a cell is selected or not. BiDi: the coordinate is visual. */
5427bool
5428Terminal::cell_is_selected_vis(bte::grid::column_t vcol,
                             bte::grid::row_t row) const
5430{
      /* Our caller had to update the ringview (we can't do because we're const). */
      g_assert(m_ringview.is_updated())do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1006
; if (m_ringview.is_updated()) _g_boolean_var_1006 = 1; else _g_boolean_var_1006
 = 0; _g_boolean_var_1006; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 5432, ((const char*) (__PRETTY_FUNCTION__
)), "m_ringview.is_updated()"); } while (0);

      /* Convert to logical column. */
      bte::base::BidiRow const* bidirow = m_ringview.get_bidirow(row);
      bte::grid::column_t lcol = bidirow->vis2log(vcol);

      return cell_is_selected_log(lcol, row);
5439}

5441void
5442Terminal::widget_paste_received(char const* text)
5443{
gchar *paste, *p;
      gsize run;
      unsigned char c;

if (text == nullptr)
              return;

      gsize len = strlen(text);
      _bte_debug_print(BTE_DEBUG_SELECTION,do { } while(0)
                       "Pasting %" G_GSIZE_FORMAT " UTF-8 bytes.\n", len)do { } while(0);
      // FIXMEchpe this cannot happen ever
      if (!g_utf8_validate(text, len, NULL__null)) {
              g_warning("Paste not valid UTF-8, dropping.");
              return;
      }

      /* Convert newlines to carriage returns, which more software
       * is able to cope with (cough, pico, cough).
       * Filter out control chars except HT, CR (even stricter than xterm).
       * Also filter out C1 controls: U+0080 (0xC2 0x80) - U+009F (0xC2 0x9F). */
      p = paste = (gchar *) g_malloc(len + 1);
      while (p != nullptr && text[0] != '\0') {
              run = strcspn(text, "\x01\x02\x03\x04\x05\x06\x07"
                            "\x08\x0A\x0B\x0C\x0E\x0F"
                            "\x10\x11\x12\x13\x14\x15\x16\x17"
                            "\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"
                            "\x7F\xC2");
              memcpy(p, text, run);
              p += run;
              text += run;
              switch (text[0]) {
              case '\x00':
                      break;
              case '\x0A':
                      *p = '\x0D';
                      p++;
                      text++;
                      break;
              case '\xC2':
                      c = text[1];
                      if (c >= 0x80 && c <= 0x9F) {
                              /* Skip both bytes of a C1 */
                              text += 2;
                      } else {
                              /* Move along, nothing to see here */
                              *p = '\xC2';
                              p++;
                              text++;
                      }
                      break;
              default:
                      /* Swallow this byte */
                      text++;
                      break;
              }
      }

      bool const bracketed_paste = m_modes_private.XTERM_READLINE_BRACKETED_PASTE();
      // FIXMEchpe can we not hardcode C0 controls here?
      if (bracketed_paste)
              feed_child("\e[200~"sv);
      // FIXMEchpe add a way to avoid the extra string copy done here
      feed_child(paste, p - paste);
      if (bracketed_paste)
              feed_child("\e[201~"sv);
      g_free(paste);
5510}

5512bool
5513Terminal::feed_mouse_event(bte::grid::coords const& rowcol /* confined */,
                                   int button,
                                   bool is_drag,
                                   bool is_release)
5517{
unsigned char cb = 0;

      /* Don't send events on scrollback contents: bug 755187. */
      if (grid_coords_in_scrollback(rowcol))
              return false;

/* Make coordinates 1-based. */
auto cx = rowcol.column() + 1;
auto cy = rowcol.row() - m_screen->insert_delta + 1;

/* Encode the button information in cb. */
switch (button) {
      case 0:                 /* No button, just dragging. */
              cb = 3;
              break;
case 1:			/* Left. */
cb = 0;
break;
case 2:			/* Middle. */
cb = 1;
break;
case 3:			/* Right. */
cb = 2;
break;
case 4:
cb = 64;	/* Scroll up. */
break;
case 5:
cb = 65;	/* Scroll down. */
break;
}

/* With the exception of the 1006 mode, button release is also encoded here. */
/* Note that if multiple extensions are enabled, the 1006 is used, so it's okay to check for only that. */
if (is_release && !m_modes_private.XTERM_MOUSE_EXT_SGR()) {
cb = 3;
}

/* Encode the modifiers. */
      if (m_mouse_tracking_mode >= MouseTrackingMode::eSEND_XY_ON_BUTTON) {
              if (m_modifiers & CDK_SHIFT_MASK) {
                      cb |= 4;
              }
              if (m_modifiers & BTE_ALT_MASKCDK_MOD1_MASK) {
                      cb |= 8;
              }
              if (m_modifiers & CDK_CONTROL_MASK) {
                      cb |= 16;
              }
      }

/* Encode a drag event. */
if (is_drag) {
cb |= 32;
}

/* Check the extensions in decreasing order of preference. Encoding the release event above assumes that 1006 comes first. */
if (m_modes_private.XTERM_MOUSE_EXT_SGR()) {
/* xterm's extended mode (1006) */
              send(is_release ? BTE_REPLY_XTERM_MOUSE_EXT_SGR_REPORT_BUTTON_RELEASE
                              : BTE_REPLY_XTERM_MOUSE_EXT_SGR_REPORT_BUTTON_PRESS,
                   {cb, (int)cx, (int)cy});
} else if (cx <= 223 && cy <= 223) {
/* legacy mode */
              char buf[8];
              size_t len = g_snprintf(buf, sizeof(buf), _BTE_CAP_CSI"\033" "[" "M%c%c%c", 32 + cb, 32 + (guchar)cx, 32 + (guchar)cy);

              /* Send event direct to the child, this is binary not text data */
              feed_child_binary({buf, len});
}

      return true;
5590}

5592void
5593Terminal::feed_focus_event(bool in)
5594{
      send(in ? BTE_REPLY_XTERM_FOCUS_IN : BTE_REPLY_XTERM_FOCUS_OUT, {});
5596}

5598void
5599Terminal::feed_focus_event_initial()
5600{
      /* We immediately send the terminal a focus event, since otherwise
       * it has no way to know the current status.
       */
      feed_focus_event(m_has_focus);
5605}

5607void
5608Terminal::maybe_feed_focus_event(bool in)
5609{
      if (m_modes_private.XTERM_FOCUS())
              feed_focus_event(in);
5612}

5614/*
* Terminal::maybe_send_mouse_button:
* @terminal:
* @event:
*
* Sends a mouse button click or release notification to the application,
* if the terminal is in mouse tracking mode.
*
* Returns: %TRUE iff the event was consumed
*/
5624bool
5625Terminal::maybe_send_mouse_button(bte::grid::coords const& unconfined_rowcol,
                                MouseEvent const& event)
5627{
switch (event.type()) {
      case EventBase::Type::eMOUSE_PRESS:
if (m_mouse_tracking_mode < MouseTrackingMode::eSEND_XY_ON_CLICK) {
	return false;
}
break;
      case EventBase::Type::eMOUSE_RELEASE:
if (m_mouse_tracking_mode < MouseTrackingMode::eSEND_XY_ON_BUTTON) {
	return false;
}
break;
      case EventBase::Type::eMOUSE_DOUBLE_PRESS:
      case EventBase::Type::eMOUSE_TRIPLE_PRESS:
default:
return false;
}

      auto rowcol = confine_grid_coords(unconfined_rowcol);
      return feed_mouse_event(rowcol,
                              event.button_value(),
                              false /* not drag */,
                              event.is_mouse_release());
5650}

5652/*
* Terminal::maybe_send_mouse_drag:
* @terminal:
* @event:
*
* Sends a mouse motion notification to the application,
* if the terminal is in mouse tracking mode.
*
* Returns: %TRUE iff the event was consumed
*/
5662bool
5663Terminal::maybe_send_mouse_drag(bte::grid::coords const& unconfined_rowcol,
                              MouseEvent const& event)
5665{
      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto rowcol = confine_grid_coords(unconfined_rowcol);

/* First determine if we even want to send notification. */
      switch (event.type()) {
      case EventBase::Type::eMOUSE_MOTION:
if (m_mouse_tracking_mode < MouseTrackingMode::eCELL_MOTION_TRACKING)
	return false;

if (m_mouse_tracking_mode < MouseTrackingMode::eALL_MOTION_TRACKING) {

                      if (m_mouse_pressed_buttons == 0) {
		return false;
	}
	/* The xterm doc is not clear as to whether
	 * all-tracking also sends degenerate same-cell events;
                       * we don't.
                       */
                      if (rowcol == confined_grid_coords_from_view_coords(m_mouse_last_position))
		return false;
}
break;
default:
return false;
}

      /* As per xterm, report the leftmost pressed button - if any. */
      int button;
      if (m_mouse_pressed_buttons & 1)
              button = 1;
      else if (m_mouse_pressed_buttons & 2)
              button = 2;
      else if (m_mouse_pressed_buttons & 4)
              button = 3;
      else
              button = 0;

      return feed_mouse_event(rowcol,
                              button,
                              true /* drag */,
                              false /* not release */);
5709}

5711/*
* Terminal::hyperlink_invalidate_and_get_bbox
*
* Invalidates cells belonging to the non-zero hyperlink idx, in order to
* stop highlighting the previously hovered hyperlink or start highlighting
* the new one. Optionally stores the coordinates of the bounding box.
*/
5718void
5719Terminal::hyperlink_invalidate_and_get_bbox(bte::base::Ring::hyperlink_idx_t idx,
                                                    CdkRectangle *bbox)
5721{
      auto first_row = first_displayed_row();
      auto end_row = last_displayed_row() + 1;
      bte::grid::row_t row, top = LONG_MAX9223372036854775807L, bottom = -1;
      bte::grid::column_t col, left = LONG_MAX9223372036854775807L, right = -1;
      const BteRowData *rowdata;

      g_assert (idx != 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1007
; if (idx != 0) _g_boolean_var_1007 = 1; else _g_boolean_var_1007
 = 0; _g_boolean_var_1007; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 5728, ((const char*) (__PRETTY_FUNCTION__
)), "idx != 0"); } while (0);

      for (row = first_row; row < end_row; row++) {
              rowdata = _bte_ring_index(m_screen->row_data, row);
              if (rowdata != NULL__null) {
                      bool do_invalidate_row = false;
                      for (col = 0; col < rowdata->len; col++) {
                              if (G_UNLIKELY (rowdata->cells[col].attr.hyperlink_idx == idx)(__builtin_expect (__extension__ ({ int _g_boolean_var_1008; if
 (rowdata->cells[col].attr.hyperlink_idx == idx) _g_boolean_var_1008
 = 1; else _g_boolean_var_1008 = 0; _g_boolean_var_1008; }), 0
))) {
                                      do_invalidate_row = true;
                                      top = MIN(top, row)(((top) < (row)) ? (top) : (row));
                                      bottom = MAX(bottom, row)(((bottom) > (row)) ? (bottom) : (row));
                                      left = MIN(left, col)(((left) < (col)) ? (left) : (col));
                                      right = MAX(right, col)(((right) > (col)) ? (right) : (col));
                              }
                      }
                      if (G_UNLIKELY (do_invalidate_row)(__builtin_expect (__extension__ ({ int _g_boolean_var_1009; if
 (do_invalidate_row) _g_boolean_var_1009 = 1; else _g_boolean_var_1009
 = 0; _g_boolean_var_1009; }), 0))) {
                              invalidate_row(row);
                      }
              }
      }

      if (bbox == NULL__null)
              return;

      /* If bbox != NULL, we're looking for the new hovered hyperlink which always has onscreen bits. */
      g_assert (top != LONG_MAX && bottom != -1 && left != LONG_MAX && right != -1)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1010
; if (top != 9223372036854775807L && bottom != -1 &&
 left != 9223372036854775807L && right != -1) _g_boolean_var_1010
 = 1; else _g_boolean_var_1010 = 0; _g_boolean_var_1010; }), 1
)) ; else g_assertion_message_expr ("BTE", "../src/bte.cc", 5753
, ((const char*) (__PRETTY_FUNCTION__)), "top != LONG_MAX && bottom != -1 && left != LONG_MAX && right != -1"
); } while (0);

      auto allocation = get_allocated_rect();
      bbox->x = allocation.x + m_padding.left + left * m_cell_width;
      bbox->y = allocation.y + m_padding.top + row_to_pixel(top);
      bbox->width = (right - left + 1) * m_cell_width;
      bbox->height = (bottom - top + 1) * m_cell_height;
      _bte_debug_print (BTE_DEBUG_HYPERLINK,do { } while(0)
                        "Hyperlink bounding box: x=%d y=%d w=%d h=%d\n",do { } while(0)
                        bbox->x, bbox->y, bbox->width, bbox->height)do { } while(0);
5763}

5765/*
* Terminal::hyperlink_hilite_update:
*
* Checks the coordinates for hyperlink. Updates m_hyperlink_hover_idx
* and m_hyperlink_hover_uri, and schedules to update the highlighting.
*/
5771void
5772Terminal::hyperlink_hilite_update()
5773{
      const BteRowData *rowdata;
      bool do_check_hilite;
      bte::grid::coords rowcol;
      bte::base::Ring::hyperlink_idx_t new_hyperlink_hover_idx = 0;
      CdkRectangle bbox;
      const char *separator;

      if (!m_allow_hyperlink)
              return;

      _bte_debug_print (BTE_DEBUG_HYPERLINK,do { } while(0)
                       "hyperlink_hilite_update\n")do { } while(0);

      /* Need to ensure the ringview is updated. */
      ringview_update();

      /* m_mouse_last_position contains the current position, see bug 789536 comment 24. */
      auto pos = m_mouse_last_position;

      /* Whether there's any chance we'd highlight something */
      do_check_hilite = view_coords_visible(pos) &&
                        m_mouse_cursor_over_widget &&
                        !(m_mouse_autohide && m_mouse_cursor_autohidden) &&
                        !m_selecting;
      if (do_check_hilite) {
              rowcol = grid_coords_from_view_coords(pos);
              rowdata = find_row_data(rowcol.row());
              if (rowdata && rowcol.column() < rowdata->len) {
                      new_hyperlink_hover_idx = rowdata->cells[rowcol.column()].attr.hyperlink_idx;
              }
      }

      if (new_hyperlink_hover_idx == m_hyperlink_hover_idx) {
              _bte_debug_print (BTE_DEBUG_HYPERLINK,do { } while(0)
                                "hyperlink did not change\n")do { } while(0);
              return;
      }

      /* Invalidate cells of the old hyperlink. */
      if (m_hyperlink_hover_idx != 0) {
              hyperlink_invalidate_and_get_bbox(m_hyperlink_hover_idx, NULL__null);
      }

      /* This might be different from new_hyperlink_hover_idx. If in the stream, that one contains
       * the pseudo idx BTE_HYPERLINK_IDX_TARGET_IN_STREAM and now a real idx is allocated.
       * Plus, the ring's internal belief of the hovered hyperlink is also updated. */
      if (do_check_hilite) {
              m_hyperlink_hover_idx = _bte_ring_get_hyperlink_at_position(m_screen->row_data, rowcol.row(), rowcol.column(), true, &m_hyperlink_hover_uri);
      } else {
              m_hyperlink_hover_idx = 0;
              m_hyperlink_hover_uri = nullptr;
      }

      /* Invalidate cells of the new hyperlink. Get the bounding box. */
      if (m_hyperlink_hover_idx != 0) {
              /* URI is after the first semicolon */
              separator = strchr(m_hyperlink_hover_uri, ';');
              g_assert(separator != NULL)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1011
; if (separator != __null) _g_boolean_var_1011 = 1; else _g_boolean_var_1011
 = 0; _g_boolean_var_1011; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 5831, ((const char*) (__PRETTY_FUNCTION__
)), "separator != NULL"); } while (0);
              m_hyperlink_hover_uri = separator + 1;

              hyperlink_invalidate_and_get_bbox(m_hyperlink_hover_idx, &bbox);
              g_assert(bbox.width > 0 && bbox.height > 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1012
; if (bbox.width > 0 && bbox.height > 0) _g_boolean_var_1012
 = 1; else _g_boolean_var_1012 = 0; _g_boolean_var_1012; }), 1
)) ; else g_assertion_message_expr ("BTE", "../src/bte.cc", 5835
, ((const char*) (__PRETTY_FUNCTION__)), "bbox.width > 0 && bbox.height > 0"
); } while (0);
      }
      _bte_debug_print(BTE_DEBUG_HYPERLINK,do { } while(0)
                       "Hover idx: %d \"%s\"\n",do { } while(0)
                       m_hyperlink_hover_idx,do { } while(0)
                       m_hyperlink_hover_uri)do { } while(0);

      /* Underlining hyperlinks has precedence over regex matches. So when the hovered hyperlink changes,
       * the regex match might need to become or stop being underlined. */
      if (regex_match_has_current())
              invalidate_match_span();

      apply_mouse_cursor();

      emit_hyperlink_hover_uri_changed(m_hyperlink_hover_idx != 0 ? &bbox : NULL__null);
5850}

5852/*
* Terminal::match_hilite_clear:
*
* Reset match variables and invalidate the old match region if highlighted.
*/
5857void
5858Terminal::match_hilite_clear()
5859{
      if (regex_match_has_current())
              invalidate_match_span();

      m_match_span.clear();
      m_match_current = nullptr;

      g_free(m_match);
      m_match = nullptr;
5868}

5870/* This is only used by the dingu matching code, so no need to extend the area. */
5871void
5872Terminal::invalidate_match_span()
5873{
      _bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                       "Invalidating match span %s\n", m_match_span.to_string())do { } while(0);
      invalidate(m_match_span);
5877}

5879/*
* Terminal::match_hilite_update:
*
* Checks the coordinates for dingu matches, setting m_match_span to
* the match region or the no-matches region, and if there is a match,
* sets it to display highlighted.
*/
5886void
5887Terminal::match_hilite_update()
5888{
      /* Need to ensure the ringview is updated. */
      ringview_update();

      /* m_mouse_last_position contains the current position, see bug 789536 comment 24. */
      auto pos = m_mouse_last_position;

      glong col = pos.x / m_cell_width;
      glong row = pixel_to_row(pos.y);

      /* BiDi: convert to logical column. */
      bte::base::BidiRow const* bidirow = m_ringview.get_bidirow(confine_grid_row(row));
      col = bidirow->vis2log(col);

_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                       "Match hilite update (%ld, %ld) -> %ld, %ld\n",do { } while(0)
                       pos.x, pos.y, col, row)do { } while(0);

      /* Whether there's any chance we'd highlight something */
      bool do_check_hilite = view_coords_visible(pos) &&
                             m_mouse_cursor_over_widget &&
                             !(m_mouse_autohide && m_mouse_cursor_autohidden) &&
                             !m_selecting;
      if (!do_check_hilite) {
              if (regex_match_has_current())
                       match_hilite_clear();
              return;
      }

      if (m_match_span.contains(row, col)) {
              /* Already highlighted. */
              return;
      }

      /* Reset match variables and invalidate the old match region if highlighted */
      match_hilite_clear();

      /* Check for matches. */
gsize start, end;
      auto new_match = match_check_internal(col,
                                            row,
                                            &m_match_current,
                                            &start,
                                            &end);

/* Read the new locations. */
if (start < m_match_attributes->len &&
          end < m_match_attributes->len) {
              struct _BteCharAttributes const *sa, *ea;
sa = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(start)])
                                 struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(start)])
                                 start)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(start)]);
              ea = &g_array_index(m_match_attributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(end)])
                                  struct _BteCharAttributes,(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(end)])
                                  end)(((struct _BteCharAttributes*) (void *) (m_match_attributes)->
data) [(end)]);

              /* convert from inclusive to exclusive (a.k.a. boundary) ending, taking a possible last CJK character into account */
              m_match_span = bte::grid::span(sa->row, sa->column, ea->row, ea->column + ea->columns);
}

      g_assert(!m_match)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1013
; if (!m_match) _g_boolean_var_1013 = 1; else _g_boolean_var_1013
 = 0; _g_boolean_var_1013; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 5948, ((const char*) (__PRETTY_FUNCTION__
)), "!m_match"); } while (0); /* from match_hilite_clear() above */
m_match = new_match;

if (m_match) {
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
		"Matched %s.\n", m_match_span.to_string())do { } while(0);
              invalidate_match_span();
      } else {
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                               "No matches %s.\n", m_match_span.to_string())do { } while(0);
}

      apply_mouse_cursor();
5961}

5963/* Note that the clipboard has cleared. */
5964static void
5965clipboard_clear_cb(CtkClipboard *clipboard,
                 gpointer user_data)
5967{
auto that = reinterpret_cast<bte::terminal::Terminal*>(user_data);
      that->widget_clipboard_cleared(clipboard);
5970}

5972void
5973Terminal::widget_clipboard_cleared(CtkClipboard *clipboard_)
5974{
      if (m_changing_selection)
              return;

if (clipboard_ == m_clipboard[BTE_SELECTION_PRIMARY]) {
if (m_selection_owned[BTE_SELECTION_PRIMARY] &&
                  !m_selection_resolved.empty()) {
	_bte_debug_print(BTE_DEBUG_SELECTION, "Lost selection.\n")do { } while(0);
	deselect_all();
}
              m_selection_owned[BTE_SELECTION_PRIMARY] = false;
} else if (clipboard_ == m_clipboard[BTE_SELECTION_CLIPBOARD]) {
              m_selection_owned[BTE_SELECTION_CLIPBOARD] = false;
      }
5988}

5990/* Supply the selected text to the clipboard. */
5991static void
5992clipboard_copy_cb(CtkClipboard *clipboard,
                CtkSelectionData *data,
                guint info,
                gpointer user_data)
5996{
auto that = reinterpret_cast<bte::terminal::Terminal*>(user_data);
      that->widget_clipboard_requested(clipboard, data, info);
5999}

6001static char*
6002text_to_utf16_mozilla(GString* text,
                    gsize* len_ptr)
6004{
      /* Use g_convert() instead of g_utf8_to_utf16() since the former
       * adds a BOM which Mozilla requires for text/html format.
       */
      return g_convert(text->str, text->len,
                       "UTF-16", /* conver to UTF-16 */
                       "UTF-8", /* convert from UTF-8 */
                       nullptr /* out bytes_read */,
                       len_ptr,
                       nullptr);
6014}

6016void
6017Terminal::widget_clipboard_requested(CtkClipboard *target_clipboard,
                                             CtkSelectionData *data,
                                             guint info)
6020{
for (auto sel = 0; sel < LAST_BTE_SELECTION; sel++) {
if (target_clipboard == m_clipboard[sel] &&
                  m_selection[sel] != nullptr) {
	_BTE_DEBUG_IF(BTE_DEBUG_SELECTION)if (0) {
		int i;
		g_printerr("Setting selection %d (%" G_GSIZE_FORMAT"lu" " UTF-8 bytes.) for target %s\n",
                                         sel,
                                         m_selection[sel]->len,
                                         cdk_atom_name(ctk_selection_data_get_target(data)));
                              char const* selection_text = m_selection[sel]->str;
                              for (i = 0; selection_text[i] != '\0'; i++) {
                                      g_printerr("0x%04x ", selection_text[i]);
                                      if ((i & 0x7) == 0x7)
                                              g_printerr("\n");
		}
                              g_printerr("\n");
	}
	if (info == BTE_TARGET_TEXT) {
		ctk_selection_data_set_text(data,
                                                          m_selection[sel]->str,
                                                          m_selection[sel]->len);
	} else if (info == BTE_TARGET_HTML) {
		gsize len;
                              auto selection = text_to_utf16_mozilla(m_selection[sel], &len);
                              // FIXMEchpe this makes yet another copy of the data... :(
                              if (selection)
                                      ctk_selection_data_set(data,
                                                             cdk_atom_intern_static_string("text/html"),
                                                             16,
                                                             (const guchar *)selection,
                                                             len);
		g_free(selection);
	} else {
                              /* Not reached */
                      }
}
}
6058}

6060/* Convert the internal color code (either index or RGB) into RGB. */
6061template <unsigned int redbits,
        unsigned int greenbits,
        unsigned int bluebits>
6064void
6065Terminal::rgb_from_index(guint index,
                                 bte::color::rgb& color) const
6067{
      bool dim = false;
      if (!(index & BTE_RGB_COLOR_MASK(redbits, greenbits, bluebits)(1U << ((redbits) + (greenbits) + (bluebits)))) && (index & BTE_DIM_COLOR(1U << 10))) {
              index &= ~BTE_DIM_COLOR(1U << 10);
              dim = true;
      }

if (index >= BTE_LEGACY_COLORS_OFFSET(1U << 9) && index < BTE_LEGACY_COLORS_OFFSET(1U << 9) + BTE_LEGACY_FULL_COLOR_SET_SIZE16)
index -= BTE_LEGACY_COLORS_OFFSET(1U << 9);
if (index < BTE_PALETTE_SIZE263) {
              color = *get_color(index);
              if (dim) {
                      /* magic formula taken from xterm */
                      color.red = color.red * 2 / 3;
                      color.green = color.green * 2 / 3;
                      color.blue = color.blue * 2 / 3;
              }
} else if (index & BTE_RGB_COLOR_MASK(redbits, greenbits, bluebits)(1U << ((redbits) + (greenbits) + (bluebits)))) {
              color.red   = BTE_RGB_COLOR_GET_COMPONENT(index, greenbits + bluebits, redbits)((((index) >> (greenbits + bluebits)) & ((1U <<
 (redbits)) - 1U)) << (8 - redbits) | ((1U << (8 -
 redbits)) >> 1)) * 0x101U;
              color.green = BTE_RGB_COLOR_GET_COMPONENT(index, bluebits, greenbits)((((index) >> (bluebits)) & ((1U << (greenbits
)) - 1U)) << (8 - greenbits) | ((1U << (8 - greenbits
)) >> 1)) * 0x101U;
              color.blue  = BTE_RGB_COLOR_GET_COMPONENT(index, 0, bluebits)((((index) >> (0)) & ((1U << (bluebits)) - 1U
)) << (8 - bluebits) | ((1U << (8 - bluebits)) >>
 1)) * 0x101U;
} else {
g_assert_not_reached()do { g_assertion_message_expr ("BTE", "../src/bte.cc", 6089, (
(const char*) (__PRETTY_FUNCTION__)), __null); } while (0);
}
6091}

6093GString*
6094Terminal::get_text(bte::grid::row_t start_row,
                           bte::grid::column_t start_col,
                           bte::grid::row_t end_row,
                           bte::grid::column_t end_col,
                           bool block,
                           bool wrap,
                           GArray *attributes)
6101{
const BteCell *pcell = NULL__null;
GString *string;
struct _BteCharAttributes attr;
bte::color::rgb fore, back;
      std::unique_ptr<bte::base::RingView> ringview;
      bte::base::BidiRow const *bidirow = nullptr;
      bte::grid::column_t vcol;

if (attributes)
g_array_set_size (attributes, 0);

string = g_string_new(NULL__null);
memset(&attr, 0, sizeof(attr));

      if (start_col < 0)
              start_col = 0;

      if (m_enable_bidi && block) {
              /* Rectangular selection operates on the visual contents, not the logical.
               * m_ringview corresponds to the currently onscreen bits, therefore does not
               * necessarily include the entire selection. Also we want m_ringview's size
               * to be limited, even if the user selects a giant rectangle.
               * So use a new ringview for the selection. */
              ringview = std::make_unique<bte::base::RingView>();
              ringview->set_ring(m_screen->row_data);
              ringview->set_rows(start_row, end_row - start_row + 1);
              ringview->set_width(m_column_count);
              ringview->update();
      }

      bte::grid::column_t lcol = block ? 0 : start_col;
      bte::grid::row_t row;
      for (row = start_row; row < end_row + 1; row++, lcol = 0) {
BteRowData const* row_data = find_row_data(row);
              gsize last_empty, last_nonempty;
              bte::grid::column_t last_emptycol, last_nonemptycol;
              bte::grid::column_t line_last_column = (!block && row == end_row) ? end_col : m_column_count;

              last_empty = last_nonempty = string->len;
              last_emptycol = last_nonemptycol = -1;

attr.row = row;
              attr.column = lcol;
pcell = NULL__null;
if (row_data != NULL__null) {
                      bidirow = ringview ? ringview->get_bidirow(row) : nullptr;
                      while (lcol < line_last_column &&
                             (pcell = _bte_row_data_get (row_data, lcol))) {

                              /* In block mode, we scan each row from its very beginning to its very end in logical order,
                               * and here filter out the characters that are visually outside of the block. */
                              if (bidirow) {
                                      vcol = bidirow->log2vis(lcol);
                                      if (vcol < start_col || vcol >= end_col) {
                                              lcol++;
                                              continue;
                                      }
                              }

                              attr.column = lcol;

		/* If it's not part of a multi-column character,
		 * and passes the selection criterion, add it to
		 * the selection. */
		if (!pcell->attr.fragment()) {
			/* Store the attributes of this character. */
                                      // FIXMEchpe shouldn't this use determine_colors?
                                      uint32_t fg, bg, dc;
                                      bte_color_triple_get(pcell->attr.colors(), &fg, &bg, &dc);
                                      rgb_from_index<8, 8, 8>(fg, fore);
                                      rgb_from_index<8, 8, 8>(bg, back);
			attr.fore.red = fore.red;
			attr.fore.green = fore.green;
			attr.fore.blue = fore.blue;
			attr.back.red = back.red;
			attr.back.green = back.green;
			attr.back.blue = back.blue;
			attr.underline = (pcell->attr.underline() == 1);
			attr.strikethrough = pcell->attr.strikethrough();
                                      attr.columns = pcell->attr.columns();

			/* Store the cell string */
			if (pcell->c == 0) {
                                              /* Empty cells of nondefault background color are
                                               * stored as NUL characters. Treat them as spaces,
                                               * but make a note of the last occurrence. */
				g_string_append_c (string, ' ')g_string_append_c_inline (string, ' ');
                                              last_empty = string->len;
                                              last_emptycol = lcol;
			} else {
				_bte_unistr_append_to_string (pcell->c, string);
                                              last_nonempty = string->len;
                                              last_nonemptycol = lcol;
			}

			/* If we added text to the string, record its
			 * attributes, one per byte. */
			if (attributes) {
				bte_g_array_fill(attributes,
						&attr, string->len);
			}
		}

                              lcol++;
	}
}

              /* Empty cells of nondefault background color can appear anywhere in a line,
               * not just at the end, e.g. between "foo" and "bar" here:
               *   echo -e '\e[46mfoo\e[K\e[7Gbar\e[m'
               * Strip off the trailing ones, preserve the middle ones. */
              if (last_empty > last_nonempty) {

                      lcol = last_emptycol + 1;

                      if (row_data != NULL__null) {
                              while ((pcell = _bte_row_data_get (row_data, lcol))) {
                                      lcol++;

                                      if (pcell->attr.fragment())
                                              continue;

                                      if (pcell->c != 0)
                                              break;
                              }
                      }
                      if (pcell == NULL__null) {
                              g_string_truncate(string, last_nonempty)g_string_truncate_inline (string, last_nonempty);
                              if (attributes)
                                      g_array_set_size(attributes, string->len);
                              attr.column = last_nonemptycol;
                      }
              }

/* Adjust column, in case we want to append a newline */
              //FIXMEchpe MIN ?
attr.column = MAX(m_column_count, attr.column + 1)(((m_column_count) > (attr.column + 1)) ? (m_column_count)
 : (attr.column + 1));

/* Add a newline in block mode. */
if (block) {
	string = g_string_append_c(string, '\n')g_string_append_c_inline (string, '\n');
}
/* Else, if the last visible column on this line was in range and
 * not soft-wrapped, append a newline. */
else if (row < end_row) {
	/* If we didn't softwrap, add a newline. */
	/* XXX need to clear row->soft_wrap on deletion! */
                      if (!m_screen->row_data->is_soft_wrapped(row)) {
		string = g_string_append_c(string, '\n')g_string_append_c_inline (string, '\n');
	}
}

/* Make sure that the attributes array is as long as the string. */
if (attributes) {
	bte_g_array_fill (attributes, &attr, string->len);
}
}

/* Sanity check. */
      if (attributes != nullptr)
              g_assert_cmpuint(string->len, ==, attributes->len)do { guint64 __n1 = (string->len), __n2 = (attributes->
len); if (__n1 == __n2) ; else g_assertion_message_cmpnum ("BTE"
, "../src/bte.cc", 6262, ((const char*) (__PRETTY_FUNCTION__)
), "string->len" " " "==" " " "attributes->len", (long double
) __n1, "==", (long double) __n2, 'i'); } while (0);

      return string;
6265}

6267GString*
6268Terminal::get_text_displayed(bool wrap,
                                     GArray *attributes)
6270{
      return get_text(first_displayed_row(), 0,
                      last_displayed_row() + 1, 0,
                      false /* block */, wrap,
                      attributes);
6275}

6277/* This is distinct from just using first/last_displayed_row since a11y
* doesn't know about sub-row displays.
*/
6280GString*
6281Terminal::get_text_displayed_a11y(bool wrap,
                                          GArray *attributes)
6283{
      return get_text(m_screen->scroll_delta, 0,
                      m_screen->scroll_delta + m_row_count - 1 + 1, 0,
                      false /* block */, wrap,
                      attributes);
6288}

6290GString*
6291Terminal::get_selected_text(GArray *attributes)
6292{
      return get_text(m_selection_resolved.start_row(),
                      m_selection_resolved.start_column(),
                      m_selection_resolved.end_row(),
                      m_selection_resolved.end_column(),
                      m_selection_block_mode,
                      true /* wrap */,
                      attributes);
6300}

6302#ifdef BTE_DEBUG
6303unsigned int
6304Terminal::checksum_area(bte::grid::row_t start_row,
                                bte::grid::column_t start_col,
                                bte::grid::row_t end_row,
                                bte::grid::column_t end_col)
6308{
      unsigned int checksum = 0;

      auto text = get_text(start_row, start_col, end_row, end_col,
                           true /* block */, false /* wrap */,
                           nullptr /* not interested in attributes */);
      if (text == nullptr)
              return checksum;

      char const* end = (char const*)text->str + text->len;
      for (char const *p = text->str; p < end; p = g_utf8_next_char(p)(char *)((p) + g_utf8_skip[*(const guchar *)(p)])) {
              auto const c = g_utf8_get_char(p);
              if (c == '\n')
                      continue;
              checksum += c;
      }
      g_string_free(text, true);

      return checksum & 0xffff;
6327}
6328#endif /* BTE_DEBUG */

6330/*
* Compares the visual attributes of a BteCellAttr for equality, but ignores
* attributes that tend to change from character to character or are otherwise
* strange (in particular: fragment, columns).
*/
6335// FIXMEchpe: make BteCellAttr a class with operator==
6336static bool
6337bte_terminal_cellattr_equal(BteCellAttr const* attr1,
                          BteCellAttr const* attr2)
6339{
      //FIXMEchpe why exclude DIM here?
return (((attr1->attr ^ attr2->attr) & BTE_ATTR_ALL_MASK(((((1U << ((1))) - 1U) << ((((0) + (4)) + (1))))
) | ((((1U << ((1))) - 1U) << (((((0) + (4)) + (1
)) + (1))))) | ((((1U << ((2))) - 1U) << ((((((0)
 + (4)) + (1)) + (1)) + (1))))) | ((((1U << ((1))) - 1U
) << (((((((0) + (4)) + (1)) + (1)) + (1)) + (2))))) | (
(((1U << ((1))) - 1U) << ((((((((0) + (4)) + (1))
 + (1)) + (1)) + (2)) + (1))))) | ((((1U << ((1))) - 1U
) << (((((((((0) + (4)) + (1)) + (1)) + (1)) + (2)) + (
1)) + (1))))) | ((((1U << ((1))) - 1U) << (((((((
(((0) + (4)) + (1)) + (1)) + (1)) + (2)) + (1)) + (1)) + (1))
))) | ((((1U << ((1))) - 1U) << ((((((((((((0) + (
4)) + (1)) + (1)) + (1)) + (2)) + (1)) + (1)) + (1)) + (1)) +
 (1))))))) == 0 &&
              attr1->colors()       == attr2->colors()   &&
              attr1->hyperlink_idx  == attr2->hyperlink_idx);
6344}

6346/*
* Wraps a given string according to the BteCellAttr in HTML tags. Used
* old-style HTML (and not CSS) for better compatibility with, for example,
* evolution's mail editor component.
*/
6351char *
6352Terminal::cellattr_to_html(BteCellAttr const* attr,
                                   char const* text) const
6354{
GString *string;
      guint fore, back, deco;

string = g_string_new(text);

      determine_colors(attr, false, false, &fore, &back, &deco);

if (attr->bold()) {
g_string_prepend(string, "<b>");
g_string_append(string, "</b>")(__builtin_constant_p ("</b>") ? __extension__ ({ const
 char * const __val = ("</b>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1014
; if (__val != __null) _g_boolean_var_1014 = 1; else _g_boolean_var_1014
 = 0; _g_boolean_var_1014; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</b>", (gssize) -1));
}
if (attr->italic()) {
g_string_prepend(string, "<i>");
g_string_append(string, "</i>")(__builtin_constant_p ("</i>") ? __extension__ ({ const
 char * const __val = ("</i>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1015
; if (__val != __null) _g_boolean_var_1015 = 1; else _g_boolean_var_1015
 = 0; _g_boolean_var_1015; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</i>", (gssize) -1));
}
      /* <u> should be inside <font> so that it inherits its color by default */
      if (attr->underline() != 0) {
              static const char styles[][7] = {"", "single", "double", "wavy"};
              char *tag, *colorattr;

              if (deco != BTE_DEFAULT_FG256) {
                      bte::color::rgb color;

                      rgb_from_index<4, 5, 4>(deco, color);
                      colorattr = g_strdup_printf(";text-decoration-color:#%02X%02X%02X",
                                                  color.red >> 8,
                                                  color.green >> 8,
                                                  color.blue >> 8);
              } else {
                      colorattr = g_strdup("")g_strdup_inline ("");
              }

              tag = g_strdup_printf("<u style=\"text-decoration-style:%s%s\">",
                                    styles[attr->underline()],
                                    colorattr);
              g_string_prepend(string, tag);
              g_free(tag);
              g_free(colorattr);
              g_string_append(string, "</u>")(__builtin_constant_p ("</u>") ? __extension__ ({ const
 char * const __val = ("</u>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1016
; if (__val != __null) _g_boolean_var_1016 = 1; else _g_boolean_var_1016
 = 0; _g_boolean_var_1016; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</u>", (gssize) -1));
      }
if (fore != BTE_DEFAULT_FG256 || attr->reverse()) {
bte::color::rgb color;
              char *tag;

              rgb_from_index<8, 8, 8>(fore, color);
tag = g_strdup_printf("<font color=\"#%02X%02X%02X\">",
                                    color.red >> 8,
                                    color.green >> 8,
                                    color.blue >> 8);
g_string_prepend(string, tag);
g_free(tag);
g_string_append(string, "</font>")(__builtin_constant_p ("</font>") ? __extension__ ({ const
 char * const __val = ("</font>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1017
; if (__val != __null) _g_boolean_var_1017 = 1; else _g_boolean_var_1017
 = 0; _g_boolean_var_1017; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</font>", (gssize) -1));
}
if (back != BTE_DEFAULT_BG257 || attr->reverse()) {
bte::color::rgb color;
              char *tag;

              rgb_from_index<8, 8, 8>(back, color);
tag = g_strdup_printf("<span style=\"background-color:#%02X%02X%02X\">",
                                    color.red >> 8,
                                    color.green >> 8,
                                    color.blue >> 8);
g_string_prepend(string, tag);
g_free(tag);
g_string_append(string, "</span>")(__builtin_constant_p ("</span>") ? __extension__ ({ const
 char * const __val = ("</span>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1018
; if (__val != __null) _g_boolean_var_1018 = 1; else _g_boolean_var_1018
 = 0; _g_boolean_var_1018; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</span>", (gssize) -1));
}
if (attr->strikethrough()) {
g_string_prepend(string, "<strike>");
g_string_append(string, "</strike>")(__builtin_constant_p ("</strike>") ? __extension__ ({ const
 char * const __val = ("</strike>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1019
; if (__val != __null) _g_boolean_var_1019 = 1; else _g_boolean_var_1019
 = 0; _g_boolean_var_1019; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</strike>", (gssize) -1));
}
if (attr->overline()) {
g_string_prepend(string, "<span style=\"text-decoration-line:overline\">");
g_string_append(string, "</span>")(__builtin_constant_p ("</span>") ? __extension__ ({ const
 char * const __val = ("</span>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1020
; if (__val != __null) _g_boolean_var_1020 = 1; else _g_boolean_var_1020
 = 0; _g_boolean_var_1020; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</span>", (gssize) -1));
}
if (attr->blink()) {
g_string_prepend(string, "<blink>");
g_string_append(string, "</blink>")(__builtin_constant_p ("</blink>") ? __extension__ ({ const
 char * const __val = ("</blink>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1021
; if (__val != __null) _g_boolean_var_1021 = 1; else _g_boolean_var_1021
 = 0; _g_boolean_var_1021; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</blink>", (gssize) -1));
}
/* reverse and invisible are not supported */

return g_string_free(string, FALSE(0));
6436}

6438/*
* Similar to find_charcell(), but takes a BteCharAttribute for
* indexing and returns the BteCellAttr.
*/
6442BteCellAttr const*
6443Terminal::char_to_cell_attr(BteCharAttributes const* attr) const
6444{
BteCell const* cell = find_charcell(attr->column, attr->row);
if (cell)
return &cell->attr;
return nullptr;
6449}

6451/*
* Terminal::attributes_to_html:
* @text: A string as returned by the bte_terminal_get_* family of functions.
* @attrs: (array) (element-type Bte.CharAttributes): text attributes, as created by bte_terminal_get_*
*
* Marks the given text up according to the given attributes, using HTML <span>
* commands, and wraps the string in a <pre> element. The attributes have to be
* "fresh" in the sense that the terminal must not have changed since they were
* obtained using the bte_terminal_get* function.
*
* Returns: (transfer full): a newly allocated text string, or %NULL.
*/
6463GString*
6464Terminal::attributes_to_html(GString* text_string,
                                     GArray* attrs)
6466{
GString *string;
guint from,to;
const BteCellAttr *attr;
char *escaped, *marked;

      char const* text = text_string->str;
      auto len = text_string->len;
      g_assert_cmpuint(len, ==, attrs->len)do { guint64 __n1 = (len), __n2 = (attrs->len); if (__n1 ==
 __n2) ; else g_assertion_message_cmpnum ("BTE", "../src/bte.cc"
, 6474, ((const char*) (__PRETTY_FUNCTION__)), "len" " " "=="
 " " "attrs->len", (long double) __n1, "==", (long double)
 __n2, 'i'); } while (0);

/* Initial size fits perfectly if the text has no attributes and no
* characters that need to be escaped
       */
string = g_string_sized_new (len + 11);

g_string_append(string, "<pre>")(__builtin_constant_p ("<pre>") ? __extension__ ({ const
 char * const __val = ("<pre>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1022
; if (__val != __null) _g_boolean_var_1022 = 1; else _g_boolean_var_1022
 = 0; _g_boolean_var_1022; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "<pre>", (gssize) -1));
/* Find streches with equal attributes. Newlines are treated specially,
* so that the <span> do not cover multiple lines.
       */
from = to = 0;
while (text[from] != '\0') {
g_assert(from == to)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1023
; if (from == to) _g_boolean_var_1023 = 1; else _g_boolean_var_1023
 = 0; _g_boolean_var_1023; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 6487, ((const char*) (__PRETTY_FUNCTION__
)), "from == to"); } while (0);
if (text[from] == '\n') {
	g_string_append_c(string, '\n')g_string_append_c_inline (string, '\n');
	from = ++to;
} else {
	attr = char_to_cell_attr(
		&g_array_index(attrs, BteCharAttributes, from)(((BteCharAttributes*) (void *) (attrs)->data) [(from)]));
	while (text[to] != '\0' && text[to] != '\n' &&
	       bte_terminal_cellattr_equal(attr,
                                                         char_to_cell_attr(
				&g_array_index(attrs, BteCharAttributes, to)(((BteCharAttributes*) (void *) (attrs)->data) [(to)]))))
	{
		to++;
	}
	escaped = g_markup_escape_text(text + from, to - from);
	marked = cellattr_to_html(attr, escaped);
	g_string_append(string, marked)(__builtin_constant_p (marked) ? __extension__ ({ const char *
 const __val = (marked); g_string_append_len_inline (string, __val
, (__builtin_expect (__extension__ ({ int _g_boolean_var_1024
; if (__val != __null) _g_boolean_var_1024 = 1; else _g_boolean_var_1024
 = 0; _g_boolean_var_1024; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, marked, (gssize) -1));
	g_free(escaped);
	g_free(marked);
	from = to;
}
}
g_string_append(string, "</pre>")(__builtin_constant_p ("</pre>") ? __extension__ ({ const
 char * const __val = ("</pre>"); g_string_append_len_inline
 (string, __val, (__builtin_expect (__extension__ ({ int _g_boolean_var_1025
; if (__val != __null) _g_boolean_var_1025 = 1; else _g_boolean_var_1025
 = 0; _g_boolean_var_1025; }), 1)) ? (gssize) strlen (((__val
) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (string, "</pre>", (gssize) -1));

return string;
6512}

6514static CtkTargetEntry*
6515targets_for_format(BteFormat format,
                 int *n_targets)
6517{
      switch (format) {
      case BTE_FORMAT_TEXT: {
              static CtkTargetEntry *text_targets = nullptr;
              static int n_text_targets;

              if (text_targets == nullptr) {
	auto list = ctk_target_list_new (nullptr, 0);
	ctk_target_list_add_text_targets (list, BTE_TARGET_TEXT);

                      text_targets = ctk_target_table_new_from_list (list, &n_text_targets);
	ctk_target_list_unref (list);
              }

              *n_targets = n_text_targets;
              return text_targets;
      }

      case BTE_FORMAT_HTML: {
              static CtkTargetEntry *html_targets = nullptr;
              static int n_html_targets;

              if (html_targets == nullptr) {
	auto list = ctk_target_list_new (nullptr, 0);
	ctk_target_list_add_text_targets (list, BTE_TARGET_TEXT);
                      ctk_target_list_add (list,
                                           cdk_atom_intern_static_string("text/html"),
                                           0,
                                           BTE_TARGET_HTML);

                      html_targets = ctk_target_table_new_from_list (list, &n_html_targets);
	ctk_target_list_unref (list);
              }

              *n_targets = n_html_targets;
              return html_targets;
      }
      default:
              g_assert_not_reached()do { g_assertion_message_expr ("BTE", "../src/bte.cc", 6555, (
(const char*) (__PRETTY_FUNCTION__)), __null); } while (0);
      }
6557}

6559/* Place the selected text onto the clipboard.  Do this asynchronously so that
* we get notified when the selection we placed on the clipboard is replaced. */
6561void
6562Terminal::widget_copy(BteSelection sel,
                              BteFormat format)
6564{
      /* Only put HTML on the CLIPBOARD, not PRIMARY */
      g_assert(sel == BTE_SELECTION_CLIPBOARD || format == BTE_FORMAT_TEXT)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1026
; if (sel == BTE_SELECTION_CLIPBOARD || format == BTE_FORMAT_TEXT
) _g_boolean_var_1026 = 1; else _g_boolean_var_1026 = 0; _g_boolean_var_1026
; }), 1)) ; else g_assertion_message_expr ("BTE", "../src/bte.cc"
, 6566, ((const char*) (__PRETTY_FUNCTION__)), "sel == BTE_SELECTION_CLIPBOARD || format == BTE_FORMAT_TEXT"
); } while (0);

/* Chuck old selected text and retrieve the newly-selected text. */
      GArray *attributes = g_array_new(FALSE(0), TRUE(!(0)), sizeof(struct _BteCharAttributes));
      auto selection = get_selected_text(attributes);

      if (m_selection[sel]) {
              g_string_free(m_selection[sel], TRUE(!(0)));
              m_selection[sel] = nullptr;
      }

      if (selection == nullptr) {
              g_array_free(attributes, TRUE(!(0)));
              m_selection_owned[sel] = false;
              return;
      }

      if (format == BTE_FORMAT_HTML) {
              m_selection[sel] = attributes_to_html(selection, attributes);
              g_string_free(selection, TRUE(!(0)));
      } else {
              m_selection[sel] = selection;
      }

g_array_free (attributes, TRUE(!(0)));

/* Place the text on the clipboard. */
      _bte_debug_print(BTE_DEBUG_SELECTION,do { } while(0)
                       "Assuming ownership of selection.\n")do { } while(0);

      int n_targets;
      auto targets = targets_for_format(format, &n_targets);

      m_changing_selection = true;
      ctk_clipboard_set_with_data(m_clipboard[sel],
                                  targets,
                                  n_targets,
                                  clipboard_copy_cb,
                                  clipboard_clear_cb,
                                  this);
      m_changing_selection = false;

      ctk_clipboard_set_can_store(m_clipboard[sel], nullptr, 0);
      m_selection_owned[sel] = true;
      m_selection_format[sel] = format;
6611}

6613/* Paste from the given clipboard. */
6614void
6615Terminal::widget_paste(CdkAtom board)
6616{
      if (!m_input_enabled)
              return;

auto clip = ctk_clipboard_get_for_display(ctk_widget_get_display(m_widget), board);
if (!clip)
              return;

      _bte_debug_print(BTE_DEBUG_SELECTION, "Requesting clipboard contents.\n")do { } while(0);

      m_paste_request.request_text(clip, &Terminal::widget_paste_received, this);
6627}

6629/* Confine coordinates into the visible area. Padding is already subtracted. */
6630void
6631Terminal::confine_coordinates(long *xp,
                                      long *yp)
6633{
long x = *xp;
long y = *yp;
      long y_stop;

      /* Allow to use the bottom extra padding only if there's content there. */
      y_stop = MIN(m_view_usable_extents.height(),(((m_view_usable_extents.height()) < (row_to_pixel(m_screen
->insert_delta + m_row_count))) ? (m_view_usable_extents.height
()) : (row_to_pixel(m_screen->insert_delta + m_row_count))
)
                   row_to_pixel(m_screen->insert_delta + m_row_count))(((m_view_usable_extents.height()) < (row_to_pixel(m_screen
->insert_delta + m_row_count))) ? (m_view_usable_extents.height
()) : (row_to_pixel(m_screen->insert_delta + m_row_count))
);

if (y < 0) {
y = 0;
if (!m_selection_block_mode)
	x = 0;
      } else if (y >= y_stop) {
              y = y_stop - 1;
if (!m_selection_block_mode)
	x = m_column_count * m_cell_width - 1;
}
if (x < 0) {
x = 0;
} else if (x >= m_column_count * m_cell_width) {
x = m_column_count * m_cell_width - 1;
}

*xp = x;
*yp = y;
6659}

6661/* Start selection at the location of the event.
* In case of regular selection, this is called with the original click's location
* once the mouse has moved by the ctk drag threshold.
*/
6665void
6666Terminal::start_selection (bte::view::coords const& pos,
                         SelectionType type)
6668{
if (m_selection_block_mode)
type = SelectionType::eCHAR;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      m_selection_origin = m_selection_last = selection_grid_halfcoords_from_view_coords(pos);

/* Record the selection type. */
m_selection_type = type;
m_selecting = TRUE(!(0));
      m_selecting_had_delta = false;  /* resolve_selection() below will most likely flip it to true. */
      m_will_select_after_threshold = false;

_bte_debug_print(BTE_DEBUG_SELECTION,do { } while(0)
                       "Selection started at %s.\n",do { } while(0)
                       m_selection_origin.to_string())do { } while(0);

      /* Take care of updating the display. */
      resolve_selection();

/* Temporarily stop caring about input from the child. */
disconnect_pty_read();
6692}

6694bool
6695Terminal::maybe_end_selection()
6696{
if (m_selecting) {
/* Copy only if something was selected. */
              if (!m_selection_resolved.empty() &&
    m_selecting_had_delta) {
                      widget_copy(BTE_SELECTION_PRIMARY, BTE_FORMAT_TEXT);
	emit_selection_changed();
}
              stop_autoscroll();  /* Required before setting m_selecting to false, see #105. */
m_selecting = false;

/* Reconnect to input from the child if we paused it. */
connect_pty_read();

return true;
}

      if (m_will_select_after_threshold)
              return true;

      return false;
6717}

6719/*
* Terminal::select_all:
*
* Selects all text within the terminal (including the scrollback buffer).
*/
6724void
6725Terminal::select_all()
6726{
deselect_all();

m_selecting_had_delta = TRUE(!(0));

      m_selection_resolved.set ({ _bte_ring_delta (m_screen->row_data), 0 },
                                { _bte_ring_next  (m_screen->row_data), 0 });

_bte_debug_print(BTE_DEBUG_SELECTION, "Selecting *all* text.\n")do { } while(0);

      widget_copy(BTE_SELECTION_PRIMARY, BTE_FORMAT_TEXT);
emit_selection_changed();

invalidate_all();
6740}

6742bool
6743Terminal::mouse_autoscroll_timer_callback()
6744{
bool extend = false;
long x, y, xmax, ymax;
glong adj;

      auto again = bool{true};

/* Provide an immediate effect for mouse wigglers. */
if (m_mouse_last_position.y < 0) {
if (m_vadjustment) {
	/* Try to scroll up by one line. */
	adj = m_screen->scroll_delta - 1;
	queue_adjustment_value_changed_clamped(adj);
	extend = true;
}
_bte_debug_print(BTE_DEBUG_EVENTS, "Autoscrolling down.\n")do { } while(0);
}
if (m_mouse_last_position.y >= m_view_usable_extents.height()) {
if (m_vadjustment) {
	/* Try to scroll up by one line. */
	adj = m_screen->scroll_delta + 1;
	queue_adjustment_value_changed_clamped(adj);
	extend = true;
}
_bte_debug_print(BTE_DEBUG_EVENTS, "Autoscrolling up.\n")do { } while(0);
}
if (extend) {
              // FIXMEchpe use confine_view_coords here
/* Don't select off-screen areas.  That just confuses people. */
xmax = m_column_count * m_cell_width;
ymax = m_row_count * m_cell_height;

x = CLAMP(m_mouse_last_position.x, 0, xmax)(((m_mouse_last_position.x) > (xmax)) ? (xmax) : (((m_mouse_last_position
.x) < (0)) ? (0) : (m_mouse_last_position.x)));
y = CLAMP(m_mouse_last_position.y, 0, ymax)(((m_mouse_last_position.y) > (ymax)) ? (ymax) : (((m_mouse_last_position
.y) < (0)) ? (0) : (m_mouse_last_position.y)));
/* If we clamped the Y, mess with the X to get the entire
 * lines. */
if (m_mouse_last_position.y < 0 && !m_selection_block_mode) {
	x = 0;
}
if (m_mouse_last_position.y >= ymax && !m_selection_block_mode) {
	x = m_column_count * m_cell_width;
}
/* Extend selection to cover the newly-scrolled area. */
              modify_selection(bte::view::coords(x, y));
} else {
/* Stop autoscrolling. */
              again = false;
}
return again;
6793}

6795/* Start autoscroll. */
6796void
6797Terminal::start_autoscroll()
6798{
if (m_mouse_autoscroll_timer)
              return;

      m_mouse_autoscroll_timer.schedule(666 / m_row_count, // FIXME WTF?
                                        bte::glib::Timer::Priority::eLOW);
6804}

6806bool
6807Terminal::widget_mouse_motion(MouseEvent const& event)
6808{
      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto pos = view_coords_from_event(event);
      auto rowcol = grid_coords_from_view_coords(pos);

_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                       "Motion notify %s %s\n",do { } while(0)
                       pos.to_string(), rowcol.to_string())do { } while(0);

      m_modifiers = event.modifiers();

      if (m_will_select_after_threshold) {
              if (!ctk_drag_check_threshold(m_widget,
                                            m_mouse_last_position.x,
                                            m_mouse_last_position.y,
                                            pos.x, pos.y))
                      return true;

              start_selection(bte::view::coords(m_mouse_last_position.x, m_mouse_last_position.y),
                              SelectionType::eCHAR);
      }

      auto handled = bool{false};
      if (m_selecting &&
          (m_mouse_handled_buttons & 1) != 0) {
              _bte_debug_print(BTE_DEBUG_EVENTS, "Mousing drag 1.\n")do { } while(0);
              modify_selection(pos);

              /* Start scrolling if we need to. */
              if (pos.y < 0 || pos.y >= m_view_usable_extents.height()) {
                      /* Give mouse wigglers something. */
                      stop_autoscroll();
                      mouse_autoscroll_timer_callback();
                      start_autoscroll();
              }

              handled = true;
      }

      if (!handled && m_input_enabled)
              maybe_send_mouse_drag(rowcol, event);

      if (pos != m_mouse_last_position) {
              m_mouse_last_position = pos;

              set_pointer_autohidden(false);
              hyperlink_hilite_update();
              match_hilite_update();
      }

return handled;
6861}

6863bool
6864Terminal::widget_mouse_press(MouseEvent const& event)
6865{
bool handled = false;
gboolean start_selecting = FALSE(0), extend_selecting = FALSE(0);

      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto pos = view_coords_from_event(event);
      auto rowcol = grid_coords_from_view_coords(pos);

      m_modifiers = event.modifiers();

      switch (event.type()) {
      case EventBase::Type::eMOUSE_PRESS:
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                               "Button %d single-click at %s\n",do { } while(0)
                               event.button_value(),do { } while(0)
                               rowcol.to_string())do { } while(0);
/* Handle this event ourselves. */
              switch (event.button()) {
              case MouseEvent::Button::eLEFT:
	_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
			"Handling click ourselves.\n")do { } while(0);
	/* Grab focus. */
	if (!m_has_focus)
                              widget()->grab_focus();

	/* If we're in event mode, and the user held down the
	 * shift key, we start selecting. */
	if (m_mouse_tracking_mode != MouseTrackingMode::eNONE) {
		if (m_modifiers & CDK_SHIFT_MASK) {
			start_selecting = TRUE(!(0));
		}
	} else {
		/* If the user hit shift, then extend the
		 * selection instead. */
		if ((m_modifiers & CDK_SHIFT_MASK) &&
                                  !m_selection_resolved.empty()) {
			extend_selecting = TRUE(!(0));
		} else {
			start_selecting = TRUE(!(0));
		}
	}
	if (start_selecting) {
		deselect_all();
                              m_will_select_after_threshold = true;
                              m_selection_block_mode = !!(m_modifiers & CDK_CONTROL_MASK);
		handled = true;
	}
	if (extend_selecting) {
		/* The whole selection code needs to be
		 * rewritten.  For now, put this here to
		 * fix bug 614658 */
		m_selecting = TRUE(!(0));
                              selection_maybe_swap_endpoints (pos);
                              modify_selection(pos);
		handled = true;
	}
	break;
/* Paste if the user pressed shift or we're not sending events
 * to the app. */
              case MouseEvent::Button::eMIDDLE:
	if ((m_modifiers & CDK_SHIFT_MASK) ||
	    m_mouse_tracking_mode == MouseTrackingMode::eNONE) {
                              if (widget()->primary_paste_enabled()) {
                                      widget_paste(CDK_SELECTION_PRIMARY((CdkAtom)((gpointer) (gulong) (1))));
                                      handled = true;
                              }
	}
	break;
              case MouseEvent::Button::eRIGHT:
default:
	break;
}
              if (event.button_value() >= 1 && event.button_value() <= 3) {
                      if (handled)
                              m_mouse_handled_buttons |= (1 << (event.button_value() - 1));
                      else
                              m_mouse_handled_buttons &= ~(1 << (event.button_value() - 1));
              }
/* If we haven't done anything yet, try sending the mouse
 * event to the app. */
if (handled == FALSE(0)) {
                      handled = maybe_send_mouse_button(rowcol, event);
}
break;
      case EventBase::Type::eMOUSE_DOUBLE_PRESS:
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                               "Button %d double-click at %s\n",do { } while(0)
                               event.button_value(),do { } while(0)
                               rowcol.to_string())do { } while(0);
              switch (event.button()) {
              case MouseEvent::Button::eLEFT:
                      if (m_will_select_after_threshold) {
                              start_selection(pos,
                                              SelectionType::eCHAR);
		handled = true;
	}
                      if ((m_mouse_handled_buttons & 1) != 0) {
                              start_selection(pos,
                                              SelectionType::eWORD);
		handled = true;
	}
	break;
              case MouseEvent::Button::eMIDDLE:
              case MouseEvent::Button::eRIGHT:
default:
	break;
}
break;
      case EventBase::Type::eMOUSE_TRIPLE_PRESS:
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                               "Button %d triple-click at %s\n",do { } while(0)
                               event.button_value(),do { } while(0)
                               rowcol.to_string())do { } while(0);
              switch (event.button()) {
              case MouseEvent::Button::eLEFT:
                      if ((m_mouse_handled_buttons & 1) != 0) {
                              start_selection(pos,
                                              SelectionType::eLINE);
		handled = true;
	}
	break;
              case MouseEvent::Button::eMIDDLE:
              case MouseEvent::Button::eRIGHT:
default:
	break;
}
default:
break;
}

/* Save the pointer state for later use. */
      if (event.button_value() >= 1 && event.button_value() <= 3)
              m_mouse_pressed_buttons |= (1 << (event.button_value() - 1));

m_mouse_last_position = pos;

      set_pointer_autohidden(false);
      hyperlink_hilite_update();
      match_hilite_update();

return handled;
7008}

7010bool
7011Terminal::widget_mouse_release(MouseEvent const& event)
7012{
bool handled = false;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto pos = view_coords_from_event(event);
      auto rowcol = grid_coords_from_view_coords(pos);

stop_autoscroll();

      m_modifiers = event.modifiers();

      switch (event.type()) {
      case EventBase::Type::eMOUSE_RELEASE:
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
                               "Button %d released at %s\n",do { } while(0)
                               event.button_value(), rowcol.to_string())do { } while(0);
              switch (event.button()) {
              case MouseEvent::Button::eLEFT:
                      if ((m_mouse_handled_buttons & 1) != 0)
                              handled = maybe_end_selection();
	break;
              case MouseEvent::Button::eMIDDLE:
                      handled = (m_mouse_handled_buttons & 2) != 0;
                      m_mouse_handled_buttons &= ~2;
	break;
              case MouseEvent::Button::eRIGHT:
default:
	break;
}
if (!handled && m_input_enabled) {
                      handled = maybe_send_mouse_button(rowcol, event);
}
break;
default:
break;
}

/* Save the pointer state for later use. */
      if (event.button_value() >= 1 && event.button_value() <= 3)
              m_mouse_pressed_buttons &= ~(1 << (event.button_value() - 1));

m_mouse_last_position = pos;
      m_will_select_after_threshold = false;

      set_pointer_autohidden(false);
      hyperlink_hilite_update();
      match_hilite_update();

return handled;
7063}

7065void
7066Terminal::widget_focus_in()
7067{
_bte_debug_print(BTE_DEBUG_EVENTS, "Focus in.\n")do { } while(0);

      m_has_focus = true;
      widget()->grab_focus();

/* We only have an IM context when we're realized, and there's not much
* point to painting the cursor if we don't have a window. */
if (widget_realized()) {
m_cursor_blink_state = TRUE(!(0));

              /* If blinking gets enabled now, do a full repaint.
               * If blinking gets disabled, only repaint if there's blinking stuff present
               * (we could further optimize by checking its current phase). */
              if (m_text_blink_mode == TextBlinkMode::eFOCUSED ||
                  (m_text_blink_mode == TextBlinkMode::eUNFOCUSED && m_text_blink_timer)) {
                      invalidate_all();
              }

check_cursor_blink();

              m_real_widget->im_focus_in();
invalidate_cursor_once();
              maybe_feed_focus_event(true);
}
7092}

7094void
7095Terminal::widget_focus_out()
7096{
_bte_debug_print(BTE_DEBUG_EVENTS, "Focus out.\n")do { } while(0);

/* We only have an IM context when we're realized, and there's not much
* point to painting ourselves if we don't have a window. */
if (widget_realized()) {
              maybe_feed_focus_event(false);

maybe_end_selection();

              /* If blinking gets enabled now, do a full repaint.
               * If blinking gets disabled, only repaint if there's blinking stuff present
               * (we could further optimize by checking its current phase). */
              if (m_text_blink_mode == TextBlinkMode::eUNFOCUSED ||
                  (m_text_blink_mode == TextBlinkMode::eFOCUSED && m_text_blink_timer)) {
                      invalidate_all();
              }

              m_real_widget->im_focus_out();
invalidate_cursor_once();

              m_mouse_pressed_buttons = 0;
              m_mouse_handled_buttons = 0;
}

m_has_focus = false;
check_cursor_blink();
7123}

7125void
7126Terminal::widget_mouse_enter(MouseEvent const& event)
7127{
      auto pos = view_coords_from_event(event);

      // FIXMEchpe read event modifiers here

_bte_debug_print(BTE_DEBUG_EVENTS, "Enter at %s\n", pos.to_string())do { } while(0);

      m_mouse_cursor_over_widget = TRUE(!(0));
      m_mouse_last_position = pos;

      set_pointer_autohidden(false);
      hyperlink_hilite_update();
      match_hilite_update();
      apply_mouse_cursor();
7141}

7143void
7144Terminal::widget_mouse_leave(MouseEvent const& event)
7145{
      auto pos = view_coords_from_event(event);

      // FIXMEchpe read event modifiers here

_bte_debug_print(BTE_DEBUG_EVENTS, "Leave at %s\n", pos.to_string())do { } while(0);

      m_mouse_cursor_over_widget = FALSE(0);
      m_mouse_last_position = pos;

      hyperlink_hilite_update();
      match_hilite_update();
      apply_mouse_cursor();
7158}

7160/* Apply the changed metrics, and queue a resize if need be.
*
* The cell's height consists of 4 parts, from top to bottom:
* - char_spacing.top: half of the extra line spacing,
* - char_ascent: the font's ascent,
* - char_descent: the font's descent,
* - char_spacing.bottom: the other half of the extra line spacing.
* Extra line spacing is typically 0, beef up cell_height_scale to get actual pixels
* here. Similarly, increase cell_width_scale to get nonzero char_spacing.{left,right}.
*/
7170void
7171Terminal::apply_font_metrics(int cell_width,
                                     int cell_height,
                                     int char_ascent,
                                     int char_descent,
                                     CtkBorder char_spacing)
7176{
      int char_height;
bool resize = false, cresize = false;

/* Sanity check for broken font changes. */
      cell_width = MAX(cell_width, 1)(((cell_width) > (1)) ? (cell_width) : (1));
      cell_height = MAX(cell_height, 2)(((cell_height) > (2)) ? (cell_height) : (2));
      char_ascent = MAX(char_ascent, 1)(((char_ascent) > (1)) ? (char_ascent) : (1));
      char_descent = MAX(char_descent, 1)(((char_descent) > (1)) ? (char_descent) : (1));

      /* For convenience only. */
      char_height = char_ascent + char_descent;

/* Change settings, and keep track of when we've changed anything. */
      if (cell_width != m_cell_width) {
resize = cresize = true;
              m_cell_width = cell_width;
}
      if (cell_height != m_cell_height) {
resize = cresize = true;
              m_cell_height = cell_height;
}
      if (char_ascent != m_char_ascent) {
resize = true;
              m_char_ascent = char_ascent;
}
      if (char_descent != m_char_descent) {
resize = true;
              m_char_descent = char_descent;
}
      if (memcmp(&char_spacing, &m_char_padding, sizeof(CtkBorder)) != 0) {
              resize = true;
              m_char_padding = char_spacing;
      }
      m_line_thickness = MAX (MIN (char_descent / 2, char_height / 14), 1)((((((char_descent / 2) < (char_height / 14)) ? (char_descent
 / 2) : (char_height / 14))) > (1)) ? ((((char_descent / 2
) < (char_height / 14)) ? (char_descent / 2) : (char_height
 / 14))) : (1));
      /* FIXME take these from pango_font_metrics_get_{underline,strikethrough}_{position,thickness} */
      m_underline_thickness = m_line_thickness;
      m_underline_position = MIN (char_spacing.top + char_ascent + m_line_thickness, cell_height - m_underline_thickness)(((char_spacing.top + char_ascent + m_line_thickness) < (cell_height
 - m_underline_thickness)) ? (char_spacing.top + char_ascent +
 m_line_thickness) : (cell_height - m_underline_thickness));
      m_double_underline_thickness = m_line_thickness;
      /* FIXME make sure this doesn't reach the baseline (switch to thinner lines, or one thicker line in that case) */
      m_double_underline_position = MIN (char_spacing.top + char_ascent + m_line_thickness, cell_height - 3 * m_double_underline_thickness)(((char_spacing.top + char_ascent + m_line_thickness) < (cell_height
 - 3 * m_double_underline_thickness)) ? (char_spacing.top + char_ascent
 + m_line_thickness) : (cell_height - 3 * m_double_underline_thickness
));
      m_undercurl_thickness = m_line_thickness;
      m_undercurl_position = MIN (char_spacing.top + char_ascent + m_line_thickness, cell_height - _bte_draw_get_undercurl_height(cell_width, m_undercurl_thickness))(((char_spacing.top + char_ascent + m_line_thickness) < (cell_height
 - _bte_draw_get_undercurl_height(cell_width, m_undercurl_thickness
))) ? (char_spacing.top + char_ascent + m_line_thickness) : (
cell_height - _bte_draw_get_undercurl_height(cell_width, m_undercurl_thickness
)));
      m_strikethrough_thickness = m_line_thickness;
      m_strikethrough_position = char_spacing.top + char_ascent - char_height / 4;
      m_overline_thickness = m_line_thickness;
      m_overline_position = char_spacing.top;  /* FIXME */
      m_regex_underline_thickness = 1;  /* FIXME */
      m_regex_underline_position = char_spacing.top + char_height - m_regex_underline_thickness;  /* FIXME */

/* Queue a resize if anything's changed. */
if (resize) {
if (widget_realized()) {
	ctk_widget_queue_resize_no_redraw(m_widget);
}
}
/* Emit a signal that the font changed. */
if (cresize) {
              if (pty()) {
                      /* Update pixel size of PTY. */
                      pty()->set_size(m_row_count,
                                      m_column_count,
                                      m_cell_height,
                                      m_cell_width);
              }
emit_char_size_changed(m_cell_width, m_cell_height);
}
/* Repaint. */
invalidate_all();
7245}

7247void
7248Terminal::ensure_font()
7249{
{
/* Load default fonts, if no fonts have been loaded. */
if (!m_has_fonts) {
	set_font_desc(m_unscaled_font_desc.get());
}
if (m_fontdirty) {
                      int cell_width, cell_height;
                      int char_ascent, char_descent;
                      CtkBorder char_spacing;
	m_fontdirty = false;
	m_draw.set_text_font(
                                               m_widget,
                                               m_fontdesc.get(),
                                               m_cell_width_scale,
                                               m_cell_height_scale);
	m_draw.get_text_metrics(
                                                  &cell_width, &cell_height,
                                                  &char_ascent, &char_descent,
                                                  &char_spacing);
                      apply_font_metrics(cell_width, cell_height,
                                         char_ascent, char_descent,
                                         char_spacing);
}
}
7274}

7276void
7277Terminal::update_font()
7278{
      /* We'll get called again later */
      if (!m_unscaled_font_desc)
              return;

      auto desc = pango_font_description_copy(m_unscaled_font_desc.get());

      double size = pango_font_description_get_size(desc);
      if (pango_font_description_get_size_is_absolute(desc)) {
              pango_font_description_set_absolute_size(desc, m_font_scale * size);
      } else {
              pango_font_description_set_size(desc, m_font_scale * size);
      }

      m_fontdesc.reset(desc); /* adopts */
      m_fontdirty = true;
      m_has_fonts = true;

      /* Set the drawing font. */
      if (widget_realized()) {
              ensure_font();
      }
7300}

7302/*
* Terminal::set_font_desc:
* @font_desc: (allow-none): a #PangoFontDescription for the desired font, or %nullptr
*
* Sets the font used for rendering all text displayed by the terminal,
* overriding any fonts set using ctk_widget_modify_font().  The terminal
* will immediately attempt to load the desired font, retrieve its
* metrics, and attempt to resize itself to keep the same number of rows
* and columns.  The font scale is applied to the specified font.
*/
7312bool
7313Terminal::set_font_desc(PangoFontDescription const* font_desc)
7314{
/* Create an owned font description. */
      PangoFontDescription *desc;

      auto context = ctk_widget_get_style_context(m_widget);
      ctk_style_context_save(context);
      ctk_style_context_set_state (context, CTK_STATE_FLAG_NORMAL);
      ctk_style_context_get(context, CTK_STATE_FLAG_NORMAL, "font", &desc, nullptr);
      ctk_style_context_restore(context);

pango_font_description_set_family_static (desc, "monospace");
if (font_desc != nullptr) {
pango_font_description_merge (desc, font_desc, TRUE(!(0)));
_BTE_DEBUG_IF(BTE_DEBUG_MISC)if (0) {
	if (desc) {
		char *tmp;
		tmp = pango_font_description_to_string(desc);
		g_printerr("Using pango font \"%s\".\n", tmp);
		g_free (tmp);
	}
}
} else {
_bte_debug_print(BTE_DEBUG_MISC,do { } while(0)
		"Using default monospace font.\n")do { } while(0);
}

      bool const same_desc = m_unscaled_font_desc &&
              pango_font_description_equal(m_unscaled_font_desc.get(), desc);

/* Note that we proceed to recreating the font even if the description
* are the same.  This is because maybe screen
* font options were changed, or new fonts installed.  Those will be
* detected at font creation time and respected.
*/

      m_unscaled_font_desc.reset(desc); /* adopts */
      update_font();

      return !same_desc;
7353}

7355bool
7356Terminal::set_font_scale(gdouble scale)
7357{
      /* FIXME: compare old and new scale in pixel space */
      if (_bte_double_equal(scale, m_font_scale))
              return false;

      m_font_scale = scale;
      update_font();

      return true;
7366}

7368bool
7369Terminal::set_cell_width_scale(double scale)
7370{
      /* FIXME: compare old and new scale in pixel space */
      if (_bte_double_equal(scale, m_cell_width_scale))
              return false;

      m_cell_width_scale = scale;
      /* Set the drawing font. */
      m_fontdirty = true;
      if (widget_realized()) {
              ensure_font();
      }

      return true;
7383}

7385bool
7386Terminal::set_cell_height_scale(double scale)
7387{
      /* FIXME: compare old and new scale in pixel space */
      if (_bte_double_equal(scale, m_cell_height_scale))
              return false;

      m_cell_height_scale = scale;
      /* Set the drawing font. */
      m_fontdirty = true;
      if (widget_realized()) {
              ensure_font();
      }

      return true;
7400}

7402/* Read and refresh our perception of the size of the PTY. */
7403void
7404Terminal::refresh_size()
7405{
      if (!pty())
              return;

int rows, columns;
      if (!pty()->get_size(&rows, &columns)) {
              /* Error reading PTY size, use defaults */
              rows = BTE_ROWS24;
              columns = BTE_COLUMNS80;
}

      if (m_row_count == rows &&
          m_column_count == columns)
              return;

      m_row_count = rows;
      m_column_count = columns;
      m_tabstops.resize(columns);
7423}

7425/* Resize the given screen (normal or alternate) of the terminal. */
7426void
7427Terminal::screen_set_size(BteScreen *screen_,
                                  long old_columns,
                                  long old_rows,
                                  bool do_rewrap)
7431{
BteRing *ring = screen_->row_data;
BteVisualPosition cursor_saved_absolute;
BteVisualPosition below_viewport;
BteVisualPosition below_current_paragraph;
      BteVisualPosition selection_start, selection_end;
BteVisualPosition *markers[7];
      gboolean was_scrolled_to_top = ((long) ceil(screen_->scroll_delta) == _bte_ring_delta(ring));
      gboolean was_scrolled_to_bottom = ((long) screen_->scroll_delta == screen_->insert_delta);
glong old_top_lines;
double new_scroll_delta;

      if (m_selection_block_mode && do_rewrap && old_columns != m_column_count)
              deselect_all();

_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
	"Resizing %s screen_\n"do { } while(0)
	"Old  insert_delta=%ld  scroll_delta=%f\n"do { } while(0)
                      "     cursor (absolute)  row=%ld  col=%ld\n"do { } while(0)
	"     cursor_saved (relative to insert_delta)  row=%ld  col=%ld\n",do { } while(0)
	screen_ == &m_normal_screen ? "normal" : "alternate",do { } while(0)
	screen_->insert_delta, screen_->scroll_delta,do { } while(0)
                      screen_->cursor.row, screen_->cursor.col,do { } while(0)
                      screen_->saved.cursor.row, screen_->saved.cursor.col)do { } while(0);

      cursor_saved_absolute.row = screen_->saved.cursor.row + screen_->insert_delta;
      cursor_saved_absolute.col = screen_->saved.cursor.col;
below_viewport.row = screen_->scroll_delta + old_rows;
below_viewport.col = 0;
      below_current_paragraph.row = screen_->cursor.row + 1;
while (below_current_paragraph.row < _bte_ring_next(ring)
   && _bte_ring_index(ring, below_current_paragraph.row - 1)->attr.soft_wrapped) {
below_current_paragraph.row++;
}
below_current_paragraph.col = 0;
      memset(&markers, 0, sizeof(markers));
      markers[0] = &cursor_saved_absolute;
      markers[1] = &below_viewport;
      markers[2] = &below_current_paragraph;
      markers[3] = &screen_->cursor;
      if (!m_selection_resolved.empty()) {
              selection_start.row = m_selection_resolved.start_row();
              selection_start.col = m_selection_resolved.start_column();
              selection_end.row = m_selection_resolved.end_row();
              selection_end.col = m_selection_resolved.end_column();
              markers[4] = &selection_start;
              markers[5] = &selection_end;
}

old_top_lines = below_current_paragraph.row - screen_->insert_delta;

if (do_rewrap && old_columns != m_column_count)
_bte_ring_rewrap(ring, m_column_count, markers);

if (_bte_ring_length(ring) > m_row_count) {
/* The content won't fit without scrollbars. Before figuring out the position, we might need to
   drop some lines from the ring if the cursor is not at the bottom, as XTerm does. See bug 708213.
   This code is really tricky, see ../doc/rewrap.txt for details! */
glong new_top_lines, drop1, drop2, drop3, drop;
screen_->insert_delta = _bte_ring_next(ring) - m_row_count;
new_top_lines = below_current_paragraph.row - screen_->insert_delta;
drop1 = _bte_ring_length(ring) - m_row_count;
drop2 = _bte_ring_next(ring) - below_current_paragraph.row;
drop3 = old_top_lines - new_top_lines;
drop = MIN(MIN(drop1, drop2), drop3)((((((drop1) < (drop2)) ? (drop1) : (drop2))) < (drop3)
) ? ((((drop1) < (drop2)) ? (drop1) : (drop2))) : (drop3));
if (drop > 0) {
	int new_ring_next = screen_->insert_delta + m_row_count - drop;
	_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
			"Dropping %ld [== MIN(%ld, %ld, %ld)] rows at the bottom\n",do { } while(0)
			drop, drop1, drop2, drop3)do { } while(0);
	_bte_ring_shrink(ring, new_ring_next - _bte_ring_delta(ring));
}
}

      if (!m_selection_resolved.empty()) {
              m_selection_resolved.set ({ selection_start.row, selection_start.col },
                                        { selection_end.row, selection_end.col });
}

/* Figure out new insert and scroll deltas */
if (_bte_ring_length(ring) <= m_row_count) {
/* Everything fits without scrollbars. Align at top. */
screen_->insert_delta = _bte_ring_delta(ring);
new_scroll_delta = screen_->insert_delta;
_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
		"Everything fits without scrollbars\n")do { } while(0);
} else {
/* Scrollbar required. Can't afford unused lines at bottom. */
screen_->insert_delta = _bte_ring_next(ring) - m_row_count;
if (was_scrolled_to_bottom) {
	/* Was scrolled to bottom, keep this way. */
	new_scroll_delta = screen_->insert_delta;
	_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
			"Scroll to bottom\n")do { } while(0);
} else if (was_scrolled_to_top) {
	/* Was scrolled to top, keep this way. Not sure if this special case is worth it. */
	new_scroll_delta = _bte_ring_delta(ring);
	_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
			"Scroll to top\n")do { } while(0);
} else {
	/* Try to scroll so that the bottom visible row stays.
	   More precisely, the character below the bottom left corner stays in that
	   (invisible) row.
	   So if the bottom of the screen_ was at a hard line break then that hard
	   line break will stay there.
	   TODO: What would be the best behavior if the bottom of the screen_ is a
	   soft line break, i.e. only a partial line is visible at the bottom? */
	new_scroll_delta = below_viewport.row - m_row_count;
	/* Keep the old fractional part. */
	new_scroll_delta += screen_->scroll_delta - floor(screen_->scroll_delta);
	_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
			"Scroll so bottom row stays\n")do { } while(0);
}
}

/* Don't clamp, they'll be clamped when restored. Until then remember off-screen_ values
  since they might become on-screen_ again on subsequent resizes. */
      screen_->saved.cursor.row = cursor_saved_absolute.row - screen_->insert_delta;
      screen_->saved.cursor.col = cursor_saved_absolute.col;

_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
	"New  insert_delta=%ld  scroll_delta=%f\n"do { } while(0)
                      "     cursor (absolute)  row=%ld  col=%ld\n"do { } while(0)
	"     cursor_saved (relative to insert_delta)  row=%ld  col=%ld\n\n",do { } while(0)
	screen_->insert_delta, new_scroll_delta,do { } while(0)
                      screen_->cursor.row, screen_->cursor.col,do { } while(0)
                      screen_->saved.cursor.row, screen_->saved.cursor.col)do { } while(0);

if (screen_ == m_screen)
queue_adjustment_value_changed(new_scroll_delta);
else
screen_->scroll_delta = new_scroll_delta;
7563}

7565void
7566Terminal::set_size(long columns,
                           long rows)
7568{
glong old_columns, old_rows;

_bte_debug_print(BTE_DEBUG_RESIZE,do { } while(0)
	"Setting PTY size to %ldx%ld.\n",do { } while(0)
	columns, rows)do { } while(0);

old_rows = m_row_count;
old_columns = m_column_count;

if (pty()) {
/* Try to set the terminal size, and read it back,
 * in case something went awry.
               */
if (!pty()->set_size(rows,
                                   columns,
                                   m_cell_height,
                                   m_cell_width)) {
                      // nothing we can do here
              }
refresh_size();
} else {
m_row_count = rows;
m_column_count = columns;
              m_tabstops.resize(columns);
}
if (old_rows != m_row_count || old_columns != m_column_count) {
              m_scrolling_restricted = FALSE(0);

              _bte_ring_set_visible_rows(m_normal_screen.row_data, m_row_count);
              _bte_ring_set_visible_rows(m_alternate_screen.row_data, m_row_count);

/* Resize the normal screen and (if rewrapping is enabled) rewrap it even if the alternate screen is visible: bug 415277 */
screen_set_size(&m_normal_screen, old_columns, old_rows, m_rewrap_on_resize);
/* Resize the alternate screen if it's the current one, but never rewrap it: bug 336238 comment 60 */
if (m_screen == &m_alternate_screen)
	screen_set_size(&m_alternate_screen, old_columns, old_rows, false);

              /* Ensure scrollback buffers cover the screen. */
              set_scrollback_lines(m_scrollback_lines);

              /* Ensure the cursor is valid */
              m_screen->cursor.row = CLAMP (m_screen->cursor.row,(((m_screen->cursor.row) > ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1)))) ? ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1))) : (((m_screen->cursor.row)
 < (_bte_ring_delta (m_screen->row_data))) ? (_bte_ring_delta
 (m_screen->row_data)) : (m_screen->cursor.row)))
                                            _bte_ring_delta (m_screen->row_data),(((m_screen->cursor.row) > ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1)))) ? ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1))) : (((m_screen->cursor.row)
 < (_bte_ring_delta (m_screen->row_data))) ? (_bte_ring_delta
 (m_screen->row_data)) : (m_screen->cursor.row)))
                                            MAX (_bte_ring_delta (m_screen->row_data),(((m_screen->cursor.row) > ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1)))) ? ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1))) : (((m_screen->cursor.row)
 < (_bte_ring_delta (m_screen->row_data))) ? (_bte_ring_delta
 (m_screen->row_data)) : (m_screen->cursor.row)))
                                                 _bte_ring_next (m_screen->row_data) - 1))(((m_screen->cursor.row) > ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1)))) ? ((((_bte_ring_delta (m_screen
->row_data)) > (_bte_ring_next (m_screen->row_data) -
 1)) ? (_bte_ring_delta (m_screen->row_data)) : (_bte_ring_next
 (m_screen->row_data) - 1))) : (((m_screen->cursor.row)
 < (_bte_ring_delta (m_screen->row_data))) ? (_bte_ring_delta
 (m_screen->row_data)) : (m_screen->cursor.row)));

adjust_adjustments_full();
ctk_widget_queue_resize_no_redraw(m_widget);
/* Our visible text changed. */
emit_text_modified();
}
7620}

7622/* Redraw the widget. */
7623static void
7624bte_terminal_vadjustment_value_changed_cb(bte::terminal::Terminal* that) noexcept
7625try
7626{
      that->vadjustment_value_changed();
7628}
7629catch (...)
7630{
      bte::log_exception();
7632}

7634void
7635Terminal::vadjustment_value_changed()
7636{
/* Read the new adjustment value and save the difference. */
      auto const adj = ctk_adjustment_get_value(m_vadjustment.get());
double dy = adj - m_screen->scroll_delta;
m_screen->scroll_delta = adj;

/* Sanity checks. */
      if (G_UNLIKELY(!widget_realized())(__builtin_expect (__extension__ ({ int _g_boolean_var_1027; if
 (!widget_realized()) _g_boolean_var_1027 = 1; else _g_boolean_var_1027
 = 0; _g_boolean_var_1027; }), 0)))
              return;

      /* FIXME: do this check in pixel space */
if (!_bte_double_equal(dy, 0)) {
_bte_debug_print(BTE_DEBUG_ADJ,do { } while(0)
	    "Scrolling by %f\n", dy)do { } while(0);
              invalidate_all();
              match_contents_clear();
emit_text_scrolled(dy);
queue_contents_changed();
} else {
_bte_debug_print(BTE_DEBUG_ADJ, "Not scrolling\n")do { } while(0);
}
7657}

7659void
7660Terminal::widget_set_vadjustment(bte::glib::RefPtr<CtkAdjustment>&& adjustment)
7661{
      if (adjustment && adjustment == m_vadjustment)
              return;
      if (!adjustment && m_vadjustment)
              return;

      if (m_vadjustment) {
/* Disconnect our signal handlers from this object. */
              g_signal_handlers_disconnect_by_func(m_vadjustment.get(),g_signal_handlers_disconnect_matched ((m_vadjustment.get()), (
GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA)
, 0, 0, __null, ((void*)bte_terminal_vadjustment_value_changed_cb
), (this))
				     (void*)bte_terminal_vadjustment_value_changed_cb,g_signal_handlers_disconnect_matched ((m_vadjustment.get()), (
GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA)
, 0, 0, __null, ((void*)bte_terminal_vadjustment_value_changed_cb
), (this))
				     this)g_signal_handlers_disconnect_matched ((m_vadjustment.get()), (
GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA)
, 0, 0, __null, ((void*)bte_terminal_vadjustment_value_changed_cb
), (this));
}

      if (adjustment)
              m_vadjustment = std::move(adjustment);
      else
              m_vadjustment = bte::glib::make_ref_sink(CTK_ADJUSTMENT(ctk_adjustment_new(0, 0, 0, 0, 0, 0))((((CtkAdjustment*) (void *) ((ctk_adjustment_new(0, 0, 0, 0,
 0, 0)))))));

/* We care about the offset, not the top or bottom. */
      g_signal_connect_swapped(m_vadjustment.get(),g_signal_connect_data ((m_vadjustment.get()), ("value-changed"
), (((GCallback) (bte_terminal_vadjustment_value_changed_cb))
), (this), __null, G_CONNECT_SWAPPED)
		 "value-changed",g_signal_connect_data ((m_vadjustment.get()), ("value-changed"
), (((GCallback) (bte_terminal_vadjustment_value_changed_cb))
), (this), __null, G_CONNECT_SWAPPED)
		 G_CALLBACK(bte_terminal_vadjustment_value_changed_cb),g_signal_connect_data ((m_vadjustment.get()), ("value-changed"
), (((GCallback) (bte_terminal_vadjustment_value_changed_cb))
), (this), __null, G_CONNECT_SWAPPED)
		 this)g_signal_connect_data ((m_vadjustment.get()), ("value-changed"
), (((GCallback) (bte_terminal_vadjustment_value_changed_cb))
), (this), __null, G_CONNECT_SWAPPED);
7684}

7686Terminal::Terminal(bte::platform::Widget* w,
                 BteTerminal *t) :
      m_real_widget(w),
      m_terminal(t),
      m_widget(&t->widget),
      m_normal_screen(BTE_SCROLLBACK_INIT512, true),
      m_alternate_screen(BTE_ROWS24, false),
      m_screen(&m_normal_screen)
7694{
widget_set_vadjustment({});

      /* Inits allocation to 1x1 @ -1,-1 */
      cairo_rectangle_int_t allocation;
      ctk_widget_get_allocation(m_widget, &allocation);
      set_allocated_rect(allocation);

int i;
CdkDisplay *display;

/* NOTE! We allocated zeroed memory, just fill in non-zero stuff. */

      // FIXMEegmont make this store row indices only, maybe convert to a bitmap
      m_update_rects = g_array_sized_new(FALSE(0) /* zero terminated */,
                                         FALSE(0) /* clear */,
                                         sizeof(cairo_rectangle_int_t),
                                         32 /* preallocated size */);

/* Set up dummy metrics, value != 0 to avoid division by 0 */
      // FIXMEchpe this is wrong. These values must not be used before
      // the view has been set up, so if they are, that's a bug
m_cell_width = 1;
m_cell_height = 1;
m_char_ascent = 1;
m_char_descent = 1;
m_char_padding = {0, 0, 0, 0};
m_line_thickness = 1;
m_underline_position = 1;
      m_double_underline_position = 1;
      m_undercurl_position = 1.;
m_strikethrough_position = 1;
      m_overline_position = 1;
      m_regex_underline_position = 1;

      reset_default_attributes(true);

/* Set up the desired palette. */
set_colors_default();
for (i = 0; i < BTE_PALETTE_SIZE263; i++)
m_palette[i].sources[BTE_COLOR_SOURCE_ESCAPE0].is_set = FALSE(0);

/* Set up I/O encodings. */
m_outgoing = _bte_byte_array_newg_byte_array_new();

/* Setting the terminal type and size requires the PTY master to
* be set up properly first. */
      set_size(BTE_COLUMNS80, BTE_ROWS24);

      /* Default is 0, forces update in bte_terminal_set_scrollback_lines */
set_scrollback_lines(BTE_SCROLLBACK_INIT512);

/* Selection info. */
display = ctk_widget_get_display(m_widget);
m_clipboard[BTE_SELECTION_PRIMARY] = ctk_clipboard_get_for_display(display, CDK_SELECTION_PRIMARY((CdkAtom)((gpointer) (gulong) (1))));
m_clipboard[BTE_SELECTION_CLIPBOARD] = ctk_clipboard_get_for_display(display, CDK_SELECTION_CLIPBOARD((CdkAtom)((gpointer) (gulong) (69))));
      m_selection_owned[BTE_SELECTION_PRIMARY] = false;
      m_selection_owned[BTE_SELECTION_CLIPBOARD] = false;

      /* Initialize the saved cursor. */
      save_cursor(&m_normal_screen);
      save_cursor(&m_alternate_screen);

/* Matching data. */
      m_match_span.clear(); // FIXMEchpe unnecessary
match_hilite_clear(); // FIXMEchpe unnecessary

      /* Word chars */
      set_word_char_exceptions(WORD_CHAR_EXCEPTIONS_DEFAULT"-#%&+,./=?@\\_~\302\267"sv);

      update_view_extents();

7766#ifdef BTE_DEBUG
      if (g_test_flags != 0) {
              feed("\e[1m\e[31mWARNING:\e[39m Test mode enabled. This is insecure!\e[0m\n\e[G"sv, false);
      }
7770#endif

7772#ifndef WITH_GNUTLS
      std::string str{"\e[1m\e[31m"};
      str.append(_("WARNING")((char *) g_dgettext ("bte-2.91", "WARNING")));
      str.append(":\e[39m ");
      str.append(_("GnuTLS not enabled; data will be written to disk unencrypted!")((char *) g_dgettext ("bte-2.91", "GnuTLS not enabled; data will be written to disk unencrypted!"
)));
      str.append("\e[0m\n\e[G");

      feed(str, false);
7780#endif
7781}

7783void
7784Terminal::widget_get_preferred_width(int *minimum_width,
                                             int *natural_width)
7786{
_bte_debug_print(BTE_DEBUG_LIFECYCLE, "bte_terminal_get_preferred_width()\n")do { } while(0);

ensure_font();

      refresh_size();

*minimum_width = m_cell_width * 2;  /* have room for a CJK or emoji */
      *natural_width = m_cell_width * m_column_count;

*minimum_width += m_padding.left +
                        m_padding.right;
*natural_width += m_padding.left +
                        m_padding.right;

_bte_debug_print(BTE_DEBUG_WIDGET_SIZE,do { } while(0)
	"[Terminal %p] minimum_width=%d, natural_width=%d for %ldx%ld cells (padding %d,%d;%d,%d).\n",do { } while(0)
                      m_terminal,do { } while(0)
	*minimum_width, *natural_width,do { } while(0)
	m_column_count,do { } while(0)
                       m_row_count,do { } while(0)
                       m_padding.left, m_padding.right, m_padding.top, m_padding.bottom)do { } while(0);
7808}

7810void
7811Terminal::widget_get_preferred_height(int *minimum_height,
                                              int *natural_height)
7813{
_bte_debug_print(BTE_DEBUG_LIFECYCLE, "bte_terminal_get_preferred_height()\n")do { } while(0);

ensure_font();

      refresh_size();

*minimum_height = m_cell_height * 1;
      *natural_height = m_cell_height * m_row_count;

*minimum_height += m_padding.top +
	   m_padding.bottom;
*natural_height += m_padding.top +
	   m_padding.bottom;

_bte_debug_print(BTE_DEBUG_WIDGET_SIZE,do { } while(0)
	"[Terminal %p] minimum_height=%d, natural_height=%d for %ldx%ld cells (padding %d,%d;%d,%d).\n",do { } while(0)
                      m_terminal,do { } while(0)
	*minimum_height, *natural_height,do { } while(0)
	m_column_count,do { } while(0)
                       m_row_count,do { } while(0)
                       m_padding.left, m_padding.right, m_padding.top, m_padding.bottom)do { } while(0);
7835}

7837void
7838Terminal::widget_size_allocate(CtkAllocation *allocation)
7839{
glong width, height;
gboolean repaint, update_scrollback;

_bte_debug_print(BTE_DEBUG_LIFECYCLE,do { } while(0)
	"bte_terminal_size_allocate()\n")do { } while(0);

width = (allocation->width - (m_padding.left + m_padding.right)) /
m_cell_width;
height = (allocation->height - (m_padding.top + m_padding.bottom)) /
 m_cell_height;
width = MAX(width, 1)(((width) > (1)) ? (width) : (1));
height = MAX(height, 1)(((height) > (1)) ? (height) : (1));

_bte_debug_print(BTE_DEBUG_WIDGET_SIZE,do { } while(0)
	"[Terminal %p] Sizing window to %dx%d (%ldx%ld, padding %d,%d;%d,%d).\n",do { } while(0)
                      m_terminal,do { } while(0)
	allocation->width, allocation->height,do { } while(0)
                       width, height,do { } while(0)
                       m_padding.left, m_padding.right, m_padding.top, m_padding.bottom)do { } while(0);

      auto current_allocation = get_allocated_rect();

repaint = current_allocation.width != allocation->width
	|| current_allocation.height != allocation->height;
update_scrollback = current_allocation.height != allocation->height;

/* Set our allocation to match the structure. */
ctk_widget_set_allocation(m_widget, allocation);
      set_allocated_rect(*allocation);

if (width != m_column_count
	|| height != m_row_count
	|| update_scrollback)
{
/* Set the size of the pseudo-terminal. */
set_size(width, height);

/* Notify viewers that the contents have changed. */
queue_contents_changed();
}

if (widget_realized()) {
/* Force a repaint if we were resized. */
if (repaint) {
	reset_update_rects();
	invalidate_all();
}
}
7888}

7890void
7891Terminal::widget_unmap()
7892{
      m_ringview.pause();
7894}

7896void
7897Terminal::widget_unrealize()
7898{
/* Deallocate the cursors. */
      m_mouse_cursor_over_widget = FALSE(0);

match_hilite_clear();

m_im_preedit_active = FALSE(0);

/* Drop font cache */
      m_draw.clear_font_cache();
m_fontdirty = true;

      /* Remove the cursor blink timeout function. */
remove_cursor_timeout();

      /* Remove the contents blink timeout function. */
      m_text_blink_timer.abort();

/* Cancel any pending redraws. */
remove_update_timeout(this);

/* Cancel any pending signals */
m_contents_changed_pending = FALSE(0);
m_cursor_moved_pending = FALSE(0);
m_text_modified_flag = FALSE(0);
m_text_inserted_flag = FALSE(0);
m_text_deleted_flag = FALSE(0);

/* Clear modifiers. */
m_modifiers = 0;
7928}

7930void
7931Terminal::set_blink_settings(bool blink,
                           int blink_time,
                           int blink_timeout) noexcept
7934{
      m_cursor_blink_cycle = blink_time / 2;
      m_cursor_blink_timeout = blink_timeout;

      update_cursor_blinks();

      /* Misuse ctk-cursor-blink-time for text blinking as well. This might change in the future. */
      m_text_blink_cycle = m_cursor_blink_cycle;
      if (m_text_blink_timer) {
              /* The current phase might have changed, and an already installed
               * timer to blink might fire too late. So remove the timer and
               * repaint the contents (which will install a correct new timer). */
              m_text_blink_timer.abort();
              invalidate_all();
      }
7949}

7951Terminal::~Terminal()
7952{
      /* Make sure not to change selection while in destruction. See issue bte#89. */
      m_changing_selection = true;

int sel;

      terminate_child();
      unset_pty(false /* don't notify widget */);
      remove_update_timeout(this);

      /* Stop processing input. */
      stop_processing(this);

/* Free matching data. */
if (m_match_attributes != NULL__null) {
g_array_free(m_match_attributes, TRUE(!(0)));
}
g_free(m_match_contents);

if (m_search_attrs)
g_array_free (m_search_attrs, TRUE(!(0)));

/* Disconnect from autoscroll requests. */
stop_autoscroll();

/* Cancel pending adjustment change notifications. */
m_adjustment_changed_pending = FALSE(0);

/* Free any selected text, but if we currently own the selection,
* throw the text onto the clipboard without an owner so that it
* doesn't just disappear. */
for (sel = BTE_SELECTION_PRIMARY; sel < LAST_BTE_SELECTION; sel++) {
if (m_selection[sel] != nullptr) {
	if (m_selection_owned[sel]) {
                              // FIXMEchpe we should check m_selection_format[sel]
                              // and also put text/html on if it's BTE_FORMAT_HTML
		ctk_clipboard_set_text(m_clipboard[sel],
				       m_selection[sel]->str,
				       m_selection[sel]->len);
	}
	g_string_free(m_selection[sel], TRUE(!(0)));
                      m_selection[sel] = nullptr;
}
}

      /* Stop listening for child-exited signals. */
      if (m_reaper) {
              g_signal_handlers_disconnect_by_func(m_reaper,g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this))
                                                   (gpointer)reaper_child_exited_cb,g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this))
                                                   this)g_signal_handlers_disconnect_matched ((m_reaper), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, __null, (
(gpointer)reaper_child_exited_cb), (this));
              g_object_unref(m_reaper);
      }

/* Discard any pending data. */
_bte_byte_array_free(m_outgoing)g_byte_array_free (m_outgoing, (!(0)));
      m_outgoing = nullptr;

/* Free public-facing data. */
      if (m_vadjustment) {
/* Disconnect our signal handlers from this object. */
              g_signal_handlers_disconnect_by_func(m_vadjustment.get(),g_signal_handlers_disconnect_matched ((m_vadjustment.get()), (
GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA)
, 0, 0, __null, ((void*)bte_terminal_vadjustment_value_changed_cb
), (this))
				     (void*)bte_terminal_vadjustment_value_changed_cb,g_signal_handlers_disconnect_matched ((m_vadjustment.get()), (
GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA)
, 0, 0, __null, ((void*)bte_terminal_vadjustment_value_changed_cb
), (this))
				     this)g_signal_handlers_disconnect_matched ((m_vadjustment.get()), (
GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA)
, 0, 0, __null, ((void*)bte_terminal_vadjustment_value_changed_cb
), (this));
}

      /* Update rects */
      g_array_free(m_update_rects, TRUE(!(0)) /* free segment */);
8019}

8021void
8022Terminal::widget_realize()
8023{
      m_mouse_cursor_over_widget = FALSE(0);  /* We'll receive an enter_notify_event if the window appears under the cursor. */

m_im_preedit_active = FALSE(0);

/* Clear modifiers. */
m_modifiers = 0;

      // Create the font cache
ensure_font();
8033}

8035static inline void
8036swap (guint *a, guint *b)
8037{
guint tmp;
tmp = *a, *a = *b, *b = tmp;
8040}

8042// FIXMEchpe probably @attr should be passed by ref
8043void
8044Terminal::determine_colors(BteCellAttr const* attr,
                                   bool is_selected,
                                   bool is_cursor,
                                   guint *pfore,
                                   guint *pback,
                                   guint *pdeco) const
8050{
      guint fore, back, deco;

      g_assert(attr)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1028
; if (attr) _g_boolean_var_1028 = 1; else _g_boolean_var_1028
 = 0; _g_boolean_var_1028; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 8053, ((const char*) (__PRETTY_FUNCTION__
)), "attr"); } while (0);

/* Start with cell colors */
      bte_color_triple_get(attr->colors(), &fore, &back, &deco);

/* Reverse-mode switches default fore and back colors */
      if (G_UNLIKELY (m_modes_private.DEC_REVERSE_IMAGE())(__builtin_expect (__extension__ ({ int _g_boolean_var_1029; if
 (m_modes_private.DEC_REVERSE_IMAGE()) _g_boolean_var_1029 = 1
; else _g_boolean_var_1029 = 0; _g_boolean_var_1029; }), 0))) {
if (fore == BTE_DEFAULT_FG256)
	fore = BTE_DEFAULT_BG257;
if (back == BTE_DEFAULT_BG257)
	back = BTE_DEFAULT_FG256;
}

/* Handle bold by using set bold color or brightening */
      if (attr->bold()) {
              if (fore == BTE_DEFAULT_FG256 && get_color(BTE_BOLD_FG258) != NULL__null) {
	fore = BTE_BOLD_FG258;
              } else if (m_bold_is_bright &&
                         fore >= BTE_LEGACY_COLORS_OFFSET(1U << 9) &&
                         fore < BTE_LEGACY_COLORS_OFFSET(1U << 9) + BTE_LEGACY_COLOR_SET_SIZE8) {
	fore += BTE_COLOR_BRIGHT_OFFSET8;
}
}

      /* Handle dim colors.  Only apply to palette colors, dimming direct RGB wouldn't make sense.
       * Apply to the foreground color only, but do this before handling reverse/highlight so that
       * those can be used to dim the background instead. */
      if (attr->dim() && !(fore & BTE_RGB_COLOR_MASK(8, 8, 8)(1U << ((8) + (8) + (8))))) {
       fore |= BTE_DIM_COLOR(1U << 10);
      }

/* Reverse cell? */
if (attr->reverse()) {
swap (&fore, &back);
}

/* Selection: use hightlight back/fore, or inverse */
if (is_selected) {
/* XXX what if hightlight back is same color as current back? */
bool do_swap = true;
if (get_color(BTE_HIGHLIGHT_BG260) != NULL__null) {
	back = BTE_HIGHLIGHT_BG260;
	do_swap = false;
}
if (get_color(BTE_HIGHLIGHT_FG259) != NULL__null) {
	fore = BTE_HIGHLIGHT_FG259;
	do_swap = false;
}
if (do_swap)
	swap (&fore, &back);
}

/* Cursor: use cursor back, or inverse */
if (is_cursor) {
/* XXX what if cursor back is same color as current back? */
              bool do_swap = true;
              if (get_color(BTE_CURSOR_BG261) != NULL__null) {
                      back = BTE_CURSOR_BG261;
                      do_swap = false;
              }
              if (get_color(BTE_CURSOR_FG262) != NULL__null) {
                      fore = BTE_CURSOR_FG262;
                      do_swap = false;
              }
              if (do_swap)
                      swap (&fore, &back);
}

/* Invisible? */
      /* FIXME: This is dead code, this is not where we actually handle invisibile.
       * Instead, draw_cells() is not called from draw_rows().
       * That is required for the foreground to be transparent if so is the background. */
      if (attr->invisible()) {
              fore = back;
              deco = BTE_DEFAULT_FG256;
}

*pfore = fore;
*pback = back;
      *pdeco = deco;
8133}

8135void
8136Terminal::determine_colors(BteCell const* cell,
                                   bool highlight,
                                   guint *fore,
                                   guint *back,
                                   guint *deco) const
8141{
determine_colors(cell ? &cell->attr : &basic_cell.attr,
                       highlight, false /* not cursor */,
                       fore, back, deco);
8145}

8147void
8148Terminal::determine_cursor_colors(BteCell const* cell,
                                          bool highlight,
                                          guint *fore,
                                          guint *back,
                                          guint *deco) const
8153{
determine_colors(cell ? &cell->attr : &basic_cell.attr,
                       highlight, true /* cursor */,
                       fore, back, deco);
8157}

8159// FIXMEchpe this constantly removes and reschedules the timer. improve this!
8160bool
8161Terminal::text_blink_timer_callback()
8162{
      invalidate_all();
      return false; /* don't run again */
8165}

8167/* Draw a string of characters with similar attributes. */
8168void
8169Terminal::draw_cells(bte::view::DrawingContext::TextRequest* items,
                             gssize n,
                             uint32_t fore,
                             uint32_t back,
                             uint32_t deco,
                             bool clear,
                             bool draw_default_bg,
                             uint32_t attr,
                             bool hyperlink,
                             bool hilite,
                             int column_width,
                             int row_height)
8181{
      int i, xl, xr, y;
gint columns = 0;
      bte::color::rgb fg, bg, dc;

g_assert(n > 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1030
; if (n > 0) _g_boolean_var_1030 = 1; else _g_boolean_var_1030
 = 0; _g_boolean_var_1030; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 8186, ((const char*) (__PRETTY_FUNCTION__
)), "n > 0"); } while (0);
8187#if 0
_BTE_DEBUG_IF(BTE_DEBUG_CELLS)if (0) {
GString *str = g_string_new (NULL__null);
gchar *tmp;
for (i = 0; i < n; i++) {
	g_string_append_unichar (str, items[i].c);
}
tmp = g_string_free (str, FALSE(0));
              g_printerr ("draw_cells('%s', fore=%d, back=%d, deco=%d, bold=%d,"
                              " ul=%d, strike=%d, ol=%d, blink=%d,"
                              " hyperlink=%d, hilite=%d, boxed=%d)\n",
                              tmp, fore, back, deco, bold,
                              underline, strikethrough, overline, blink,
                              hyperlink, hilite, boxed);
g_free (tmp);
}
8203#endif

      rgb_from_index<8, 8, 8>(fore, fg);
      rgb_from_index<8, 8, 8>(back, bg);
      // FIXMEchpe defer resolving deco color until we actually need to draw an underline?
      if (deco == BTE_DEFAULT_FG256)
              dc = fg;
      else
              rgb_from_index<4, 5, 4>(deco, dc);

      if (clear && (draw_default_bg || back != BTE_DEFAULT_BG257)) {
              /* Paint the background. */
              i = 0;
              while (i < n) {
                      xl = items[i].x;
                      xr = items[i].x + items[i].columns * column_width;
                      y = items[i].y;
                      /* Items are not necessarily contiguous in LTR order.
                       * Combine as long as they form a single visual run. */
                      for (i++; i < n && items[i].y == y; i++) {
                              if (G_LIKELY (items[i].x == xr)(__builtin_expect (__extension__ ({ int _g_boolean_var_1031; if
 (items[i].x == xr) _g_boolean_var_1031 = 1; else _g_boolean_var_1031
 = 0; _g_boolean_var_1031; }), 1))) {
                                      xr += items[i].columns * column_width;  /* extend to the right */
                              } else if (items[i].x + items[i].columns * column_width == xl) {
                                      xl = items[i].x;                        /* extend to the left */
                              } else {
                                      break;                                  /* break the run */
                              }
                      }
	m_draw.fill_rectangle(
                                               xl,
                                               y,
                                               xr - xl, row_height,
                                               &bg, BTE_DRAW_OPAQUE(1.0));
              }
      }

      if (attr & BTE_ATTR_BLINK(1U << (((((((((0) + (4)) + (1)) + (1)) + (1)) + (2)) +
 (1)) + (1)) + (1)))) {
              /* Notify the caller that cells with the "blink" attribute were encountered (regardless of
               * whether they're actually painted or skipped now), so that the caller can set up a timer
               * to make them blink if it wishes to. */
              m_text_to_blink = true;

              /* This is for the "off" state of blinking text. Invisible text could also be handled here,
               * but it's not, it's handled outside by not even calling this method.
               * Setting fg = bg and painting the text would not work for two reasons: it'd be opaque
               * even if the background is translucent, and this method can be called with a continuous
               * run of identical fg, yet different bg colored cells. So we simply bail out. */
              if (!m_text_blink_state)
                      return;
      }

      /* Draw whatever SFX are required. Do this before drawing the letters,
       * so that if the descent of a letter crosses an underline of a different color,
       * it's the letter's color that wins. Other kinds of decorations always have the
       * same color as the text, so the order is irrelevant there. */
      if ((attr & (BTE_ATTR_UNDERLINE_MASK((((1U << ((2))) - 1U) << ((((((0) + (4)) + (1)) +
 (1)) + (1))))) |
                   BTE_ATTR_STRIKETHROUGH_MASK((((1U << ((1))) - 1U) << (((((((0) + (4)) + (1))
 + (1)) + (1)) + (2))))) |
                   BTE_ATTR_OVERLINE_MASK((((1U << ((1))) - 1U) << ((((((((0) + (4)) + (1)
) + (1)) + (1)) + (2)) + (1))))) |
                   BTE_ATTR_BOXED_MASK((((1U << ((1))) - 1U) << ((31)))))) |
          hyperlink | hilite) {
i = 0;
              while (i < n) {
                      xl = items[i].x;
                      xr = items[i].x + items[i].columns * column_width;
                      columns = items[i].columns;
	y = items[i].y;
                      /* Items are not necessarily contiguous in LTR order.
                       * Combine as long as they form a single visual run. */
                      for (i++; i < n && items[i].y == y; i++) {
                              if (G_LIKELY (items[i].x == xr)(__builtin_expect (__extension__ ({ int _g_boolean_var_1032; if
 (items[i].x == xr) _g_boolean_var_1032 = 1; else _g_boolean_var_1032
 = 0; _g_boolean_var_1032; }), 1))) {
                                      xr += items[i].columns * column_width;  /* extend to the right */
                                      columns += items[i].columns;
                              } else if (items[i].x + items[i].columns * column_width == xl) {
                                      xl = items[i].x;                        /* extend to the left */
                                      columns += items[i].columns;
                              } else {
                                      break;                                  /* break the run */
                              }
	}
                      switch (bte_attr_get_value(attr, BTE_ATTR_UNDERLINE_VALUE_MASK(((1U << ((2))) - 1U)), BTE_ATTR_UNDERLINE_SHIFT(((((0) + (4)) + (1)) + (1)) + (1)))) {
                      case 1:
                              m_draw.draw_line(
                                                  xl,
                                                  y + m_underline_position,
                                                  xr - 1,
                                                  y + m_underline_position + m_underline_thickness - 1,
                                                  BTE_LINE_WIDTH1,
                                                  &dc, BTE_DRAW_OPAQUE(1.0));
                              break;
                      case 2:
                              m_draw.draw_line(
                                                  xl,
                                                  y + m_double_underline_position,
                                                  xr - 1,
                                                  y + m_double_underline_position + m_double_underline_thickness - 1,
                                                  BTE_LINE_WIDTH1,
                                                  &dc, BTE_DRAW_OPAQUE(1.0));
                              m_draw.draw_line(
                                                  xl,
                                                  y + m_double_underline_position + 2 * m_double_underline_thickness,
                                                  xr - 1,
                                                  y + m_double_underline_position + 3 * m_double_underline_thickness - 1,
                                                  BTE_LINE_WIDTH1,
                                                  &dc, BTE_DRAW_OPAQUE(1.0));
                              break;
                      case 3:
                              m_draw.draw_undercurl(
                                                       xl,
                                                       y + m_undercurl_position,
                                                       m_undercurl_thickness,
                                                       columns,
                                                       &dc, BTE_DRAW_OPAQUE(1.0));
                              break;
	}
	if (attr & BTE_ATTR_STRIKETHROUGH(1U << ((((((0) + (4)) + (1)) + (1)) + (1)) + (2)))) {
                              m_draw.draw_line(
                                                  xl,
                                                  y + m_strikethrough_position,
                                                  xr - 1,
                                                  y + m_strikethrough_position + m_strikethrough_thickness - 1,
                                                  BTE_LINE_WIDTH1,
                                                  &fg, BTE_DRAW_OPAQUE(1.0));
	}
                      if (attr & BTE_ATTR_OVERLINE(1U << (((((((0) + (4)) + (1)) + (1)) + (1)) + (2)) + (
1)))) {
                              m_draw.draw_line(
                                                  xl,
                                                  y + m_overline_position,
                                                  xr - 1,
                                                  y + m_overline_position + m_overline_thickness - 1,
                                                  BTE_LINE_WIDTH1,
                                                  &fg, BTE_DRAW_OPAQUE(1.0));
                      }
	if (hilite) {
                              m_draw.draw_line(
                                                  xl,
                                                  y + m_regex_underline_position,
                                                  xr - 1,
                                                  y + m_regex_underline_position + m_regex_underline_thickness - 1,
                                                  BTE_LINE_WIDTH1,
                                                  &fg, BTE_DRAW_OPAQUE(1.0));
                      } else if (hyperlink) {
                              for (double j = 1.0 / 6.0; j < columns; j += 0.5) {
                                      m_draw.fill_rectangle(
                                                               xl + j * column_width,
                                                               y + m_regex_underline_position,
                                                               MAX(column_width / 6.0, 1.0)(((column_width / 6.0) > (1.0)) ? (column_width / 6.0) : (
0)),
                                                               m_regex_underline_thickness,
                                                               &fg, BTE_DRAW_OPAQUE(1.0));
                              }
                      }
	if (attr & BTE_ATTR_BOXED(1U << (31))) {
                              m_draw.draw_rectangle(
                                                       xl,
                                                       y,
                                                       xr - xl,
                                                       row_height,
                                                       &fg, BTE_DRAW_OPAQUE(1.0));
	}
              }
}

      m_draw.draw_text(
                     items, n,
                     attr,
                     &fg, BTE_DRAW_OPAQUE(1.0));
8368}

8370/* FIXME: we don't have a way to tell CTK+ what the default text attributes
* should be, so for now at least it's assuming white-on-black is the norm and
* is using "black-on-white" to signify "inverse".  Pick up on that state and
* fix things.  Do this here, so that if we suddenly get red-on-black, we'll do
* the right thing. */
8375void
8376Terminal::fudge_pango_colors(GSList *attributes,
                                     BteCell *cells,
                                     gsize n)
8379{
gsize i, sumlen = 0;
struct _fudge_cell_props{
gboolean saw_fg, saw_bg;
bte::color::rgb fg, bg;
guint index;
}*props = g_newa (struct _fudge_cell_props, n)((struct _fudge_cell_props*) __builtin_alloca (sizeof (struct
 _fudge_cell_props) * (gsize) (n)));

for (i = 0; i < n; i++) {
55
←
Assuming 'i' is < 'n'→
56
←
Loop condition is true.  Entering loop body→
gchar ubuf[7];
gint len = g_unichar_to_utf8 (cells[i].c, ubuf);
57
←
1st function call argument is an uninitialized value
props[i].index = sumlen;
props[i].saw_fg = props[i].saw_bg = FALSE(0);
sumlen += len;
}

while (attributes != NULL__null) {
PangoAttribute *attr = (PangoAttribute *)attributes->data;
PangoAttrColor *color;
switch (attr->klass->type) {
case PANGO_ATTR_FOREGROUND:
	for (i = 0; i < n; i++) {
		if (props[i].index < attr->start_index) {
			continue;
		}
		if (props[i].index >= attr->end_index) {
			break;
		}
		props[i].saw_fg = TRUE(!(0));
		color = (PangoAttrColor*) attr;
		props[i].fg = color->color;
	}
	break;
case PANGO_ATTR_BACKGROUND:
	for (i = 0; i < n; i++) {
		if (props[i].index < attr->start_index) {
			continue;
		}
		if (props[i].index >= attr->end_index) {
			break;
		}
		props[i].saw_bg = TRUE(!(0));
		color = (PangoAttrColor*) attr;
		props[i].bg = color->color;
	}
	break;
default:
	break;
}
attributes = g_slist_next(attributes)((attributes) ? (((GSList *)(attributes))->next) : __null);
}

for (i = 0; i < n; i++) {
if (props[i].saw_fg && props[i].saw_bg &&
		(props[i].fg.red == 0xffff) &&
		(props[i].fg.green == 0xffff) &&
		(props[i].fg.blue == 0xffff) &&
		(props[i].bg.red == 0) &&
		(props[i].bg.green == 0) &&
		(props[i].bg.blue == 0)) {
                      cells[i].attr.copy_colors(m_color_defaults.attr);
	cells[i].attr.set_reverse(true);
}
}
8443}

8445/* Apply the attribute given in the PangoAttribute to the list of cells. */
8446void
8447Terminal::apply_pango_attr(PangoAttribute *attr,
                                   BteCell *cells,
                                   gsize n_cells)
8450{
guint i, ival;
PangoAttrInt *attrint;
PangoAttrColor *attrcolor;

switch (attr->klass->type) {
46
←
Control jumps to the 'default' case at line 8540→
47
←
 Execution continues on line 8455→
case PANGO_ATTR_FOREGROUND:
case PANGO_ATTR_BACKGROUND:
attrcolor = (PangoAttrColor*) attr;
              ival = BTE_RGB_COLOR(8, 8, 8,((1U << ((8) + (8) + (8))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (8))) & ((1U
 << (8)) - 1U)) << ((8) + (8))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (8)
)) & ((1U << (8)) - 1U)) << (8)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (8))
) & ((1U << (8)) - 1U)))
                                   ((attrcolor->color.red & 0xFF00) >> 8),((1U << ((8) + (8) + (8))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (8))) & ((1U
 << (8)) - 1U)) << ((8) + (8))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (8)
)) & ((1U << (8)) - 1U)) << (8)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (8))
) & ((1U << (8)) - 1U)))
                                   ((attrcolor->color.green & 0xFF00) >> 8),((1U << ((8) + (8) + (8))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (8))) & ((1U
 << (8)) - 1U)) << ((8) + (8))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (8)
)) & ((1U << (8)) - 1U)) << (8)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (8))
) & ((1U << (8)) - 1U)))
                                   ((attrcolor->color.blue & 0xFF00) >> 8))((1U << ((8) + (8) + (8))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (8))) & ((1U
 << (8)) - 1U)) << ((8) + (8))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (8)
)) & ((1U << (8)) - 1U)) << (8)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (8))
) & ((1U << (8)) - 1U)));
for (i = attr->start_index;
     i < attr->end_index && i < n_cells;
     i++) {
	if (attr->klass->type == PANGO_ATTR_FOREGROUND) {
                              cells[i].attr.set_fore(ival);
	}
	if (attr->klass->type == PANGO_ATTR_BACKGROUND) {
                              cells[i].attr.set_back(ival);
	}
}
break;
case PANGO_ATTR_UNDERLINE_COLOR:
attrcolor = (PangoAttrColor*) attr;
              ival = BTE_RGB_COLOR(4, 5, 4,((1U << ((4) + (5) + (4))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (4))) & ((1U
 << (4)) - 1U)) << ((5) + (4))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (5)
)) & ((1U << (5)) - 1U)) << (4)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (4))
) & ((1U << (4)) - 1U)))
                                   ((attrcolor->color.red & 0xFF00) >> 8),((1U << ((4) + (5) + (4))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (4))) & ((1U
 << (4)) - 1U)) << ((5) + (4))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (5)
)) & ((1U << (5)) - 1U)) << (4)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (4))
) & ((1U << (4)) - 1U)))
                                   ((attrcolor->color.green & 0xFF00) >> 8),((1U << ((4) + (5) + (4))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (4))) & ((1U
 << (4)) - 1U)) << ((5) + (4))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (5)
)) & ((1U << (5)) - 1U)) << (4)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (4))
) & ((1U << (4)) - 1U)))
                                   ((attrcolor->color.blue & 0xFF00) >> 8))((1U << ((4) + (5) + (4))) | ((((((attrcolor->color.
red & 0xFF00) >> 8)) >> (8 - (4))) & ((1U
 << (4)) - 1U)) << ((5) + (4))) | ((((((attrcolor
->color.green & 0xFF00) >> 8)) >> (8 - (5)
)) & ((1U << (5)) - 1U)) << (4)) | (((((attrcolor
->color.blue & 0xFF00) >> 8)) >> (8 - (4))
) & ((1U << (4)) - 1U)));
for (i = attr->start_index;
     i < attr->end_index && i < n_cells;
     i++) {
	if (attr->klass->type == PANGO_ATTR_UNDERLINE) {
                              cells[i].attr.set_deco(ival);
	}
}
break;
case PANGO_ATTR_STRIKETHROUGH:
attrint = (PangoAttrInt*) attr;
ival = attrint->value;
for (i = attr->start_index;
     (i < attr->end_index) && (i < n_cells);
     i++) {
	cells[i].attr.set_strikethrough(ival != FALSE(0));
}
break;
case PANGO_ATTR_UNDERLINE:
attrint = (PangoAttrInt*) attr;
ival = attrint->value;
for (i = attr->start_index;
     (i < attr->end_index) && (i < n_cells);
     i++) {
                      unsigned int underline = 0;
                      switch (ival) {
                      case PANGO_UNDERLINE_SINGLE:
                              underline = 1;
                              break;
                      case PANGO_UNDERLINE_DOUBLE:
                              underline = 2;
                              break;
                      case PANGO_UNDERLINE_ERROR:
                              underline = 3; /* wavy */
                              break;
                      case PANGO_UNDERLINE_NONE:
                      case PANGO_UNDERLINE_LOW: /* FIXME */
                              underline = 0;
                              break;
                      }
	cells[i].attr.set_underline(underline);
}
break;
case PANGO_ATTR_WEIGHT:
attrint = (PangoAttrInt*) attr;
ival = attrint->value;
for (i = attr->start_index;
     (i < attr->end_index) && (i < n_cells);
     i++) {
	cells[i].attr.set_bold(ival >= PANGO_WEIGHT_BOLD);
}
break;
case PANGO_ATTR_STYLE:
attrint = (PangoAttrInt*) attr;
ival = attrint->value;
for (i = attr->start_index;
     (i < attr->end_index) && (i < n_cells);
     i++) {
	cells[i].attr.set_italic(ival != PANGO_STYLE_NORMAL);
}
break;
default:
break;
}
8543}

8545/* Convert a PangoAttrList and a location in that list to settings in a
* charcell structure.  The cells array is assumed to contain enough items
* so that all ranges in the attribute list can be mapped into the array, which
* typically means that the cell array should have the same length as the
* string (byte-wise) which the attributes describe. */
8550void
8551Terminal::translate_pango_cells(PangoAttrList *attrs,
                                        BteCell *cells,
                                        gsize n_cells)
8554{
PangoAttribute *attr;
PangoAttrIterator *attriter;
GSList *list, *listiter;
guint i;

for (i = 0; i < n_cells; i++) {
38
←
Assuming 'i' is >= 'n_cells'→
39
←
Loop condition is false. Execution continues on line 8564→
              cells[i] = m_color_defaults;
}

attriter = pango_attr_list_get_iterator(attrs);
if (attriter != NULL__null) {
40
←
Assuming 'attriter' is not equal to NULL→
41
←
Taking true branch→
do {
	list = pango_attr_iterator_get_attrs(attriter);
	if (list != NULL__null) {
42
←
Assuming 'list' is not equal to NULL→
43
←
Taking true branch→
		for (listiter = list;
44
←
Loop condition is true.  Entering loop body→
51
←
Loop condition is false. Execution continues on line 8575→
		     listiter43.1
'listiter' is not equal to NULL
 != NULL__null;
50
←
Assuming 'listiter' is equal to NULL→
		     listiter = g_slist_next(listiter)((listiter) ? (((GSList *)(listiter))->next) : __null)) {
49
←
'?' condition is true→
			attr = (PangoAttribute *)listiter->data;
			apply_pango_attr(attr, cells, n_cells);
45
←
Calling 'Terminal::apply_pango_attr'→
48
←
Returning from 'Terminal::apply_pango_attr'→
		}
		attr = (PangoAttribute *)list->data;
		fudge_pango_colors(
54
←
Calling 'Terminal::fudge_pango_colors'→
						 list,
						 cells +
						 attr->start_index,
						 MIN(n_cells, attr->end_index)(((n_cells) < (attr->end_index)) ? (n_cells) : (attr->
end_index)) -
52
←
Assuming 'n_cells' is < field 'end_index'→
53
←
'?' condition is true→
						 attr->start_index);
		g_slist_free_full(list, (GDestroyNotify)pango_attribute_destroy);
	}
} while (pango_attr_iterator_next(attriter) == TRUE(!(0)));
pango_attr_iterator_destroy(attriter);
}
8587}

8589/* Draw the listed items using the given attributes.  Tricky because the
* attribute string is indexed by byte in the UTF-8 representation of the string
* of characters.  Because we draw a character at a time, this is slower. */
8592void
8593Terminal::draw_cells_with_attributes(bte::view::DrawingContext::TextRequest* items,
                                             gssize n,
                                             PangoAttrList *attrs,
                                             bool draw_default_bg,
                                             gint column_width,
                                             gint height)
8599{
      int i, j, cell_count;
BteCell *cells;
char scratch_buf[BTE_UTF8_BPC(4)];
      guint fore, back, deco;

/* Note: since this function is only called with the pre-edit text,
* all the items contain gunichar only, not bteunistr. */
      // FIXMEchpe is that really true for all input methods?

      uint32_t const attr_mask = m_allow_bold ? ~0 : ~BTE_ATTR_BOLD_MASK((((1U << ((1))) - 1U) << ((((0) + (4)) + (1)))));
31
←
Assuming field 'm_allow_bold' is false→
32
←
'?' condition is false→

for (i = 0, cell_count = 0; i < n; i++) {
33
←
Loop condition is true.  Entering loop body→
34
←
Loop condition is false. Execution continues on line 8614→
cell_count += g_unichar_to_utf8(items[i].c, scratch_buf);
}
cells = g_new(BteCell, cell_count)(BteCell *) (__extension__ ({ gsize __n = (gsize) (cell_count
); gsize __s = sizeof (BteCell); gpointer __p; if (__s == 1) __p
 = g_malloc (__n); else if (__builtin_constant_p (__n) &&
 (__s == 0 || __n <= (9223372036854775807L *2UL+1UL) / __s
)) __p = g_malloc (__n * __s); else __p = g_malloc_n (__n, __s
); __p; }));
35
←
Taking false branch→
36
←
Uninitialized value stored to field 'c'→
translate_pango_cells(attrs, cells, cell_count);
37
←
Calling 'Terminal::translate_pango_cells'→
for (i = 0, j = 0; i < n; i++) {
              determine_colors(&cells[j], false, &fore, &back, &deco);
draw_cells(items + i, 1,
			fore,
			back,
                                      deco,
			TRUE(!(0)), draw_default_bg,
			cells[j].attr.attr & attr_mask,
                                      m_allow_hyperlink && cells[j].attr.hyperlink_idx != 0,
			FALSE(0), column_width, height);
j += g_unichar_to_utf8(items[i].c, scratch_buf);
}
g_free(cells);
8629}

8631void
8632Terminal::ringview_update()
8633{
      auto first_row = first_displayed_row();
      auto last_row = last_displayed_row();
      if (cursor_is_onscreen())
              last_row = std::max(last_row, m_screen->cursor.row);

      m_ringview.set_ring (m_screen->row_data);
      m_ringview.set_rows (first_row, last_row - first_row + 1);
      m_ringview.set_width (m_column_count);
      m_ringview.set_enable_bidi (m_enable_bidi);
      m_ringview.set_enable_shaping (m_enable_shaping);
      m_ringview.update ();
8645}

8647/* Paint the contents of a given row at the given location.  Take advantage
* of multiple-draw APIs by finding runs of characters with identical
* attributes and bundling them together. */
8650void
8651Terminal::draw_rows(BteScreen *screen_,
                  cairo_region_t const* region,
                  bte::grid::row_t start_row,
                  bte::grid::row_t end_row,
                  gint start_y, /* must be the start of a row */
                  gint column_width,
                  gint row_height)
8658{
      bte::grid::row_t row;
      bte::grid::column_t i, j, lcol, vcol;
      int y;
      guint fore = BTE_DEFAULT_FG256, nfore, back = BTE_DEFAULT_BG257, nback, deco = BTE_DEFAULT_FG256, ndeco;
      gboolean hyperlink = FALSE(0), nhyperlink;  /* non-hovered explicit hyperlink, needs dashed underlining */
      gboolean hilite = FALSE(0), nhilite;        /* hovered explicit hyperlink or regex match, needs continuous underlining */
      gboolean selected;
      gboolean nrtl = FALSE(0), rtl;  /* for debugging */
      uint32_t attr = 0, nattr;
guint item_count;
const BteCell *cell;
BteRowData const* row_data;
      bte::base::BidiRow const* bidirow;

      auto const column_count = m_column_count;
      uint32_t const attr_mask = m_allow_bold ? ~0 : ~BTE_ATTR_BOLD_MASK((((1U << ((1))) - 1U) << ((((0) + (4)) + (1)))));

      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto items = g_newa(bte::view::DrawingContext::TextRequest, column_count)((bte::view::DrawingContext::TextRequest*) __builtin_alloca (
sizeof (bte::view::DrawingContext::TextRequest) * (gsize) (column_count
)));

      /* Paint the background.
       * Do it first for all the cells we're about to paint, before drawing the glyphs,
       * so that overflowing bits of a glyph (to the right or downwards) won't be
       * chopped off by another cell's background, not even across changes of the
       * background or any other attribute.
       * Process each row independently. */
      int const rect_width = get_allocated_width();

      /* The rect contains the area of the row, and is moved row-wise in the loop. */
      auto rect = cairo_rectangle_int_t{-m_padding.left, start_y, rect_width, row_height};
      for (row = start_row, y = start_y;
           row < end_row;
           row++, y += row_height, rect.y = y /* same as rect.y += row_height */) {
              /* Check whether we need to draw this row at all */
              if (cairo_region_contains_rectangle(region, &rect) == CAIRO_REGION_OVERLAP_OUT)
                      continue;

row_data = find_row_data(row);
              bidirow = m_ringview.get_bidirow(row);

              _BTE_DEBUG_IF (BTE_DEBUG_BIDI)if (0) {
                      /* Debug: Highlight the paddings of RTL rows with a slightly different background. */
                      if (bidirow->base_is_rtl()) {
                              bte::color::rgb bg;
                              rgb_from_index<8, 8, 8>(BTE_DEFAULT_BG257, bg);
                              /* Go halfway towards #C0C0C0. */
                              bg.red   = (bg.red   + 0xC000) / 2;
                              bg.green = (bg.green + 0xC000) / 2;
                              bg.blue  = (bg.blue  + 0xC000) / 2;
                              m_draw.fill_rectangle(
                                                        -m_padding.left,
                                                        y,
                                                        m_padding.left,
                                                        row_height,
                                                        &bg, BTE_DRAW_OPAQUE(1.0));
                              m_draw.fill_rectangle(
                                                        column_count * column_width,
                                                        y,
                                                        rect_width - m_padding.left - column_count * column_width,
                                                        row_height,
                                                        &bg, BTE_DRAW_OPAQUE(1.0));
                      }
              }

              i = j = 0;
              /* Walk the line.
               * Locate runs of identical bg colors within a row, and paint each run as a single rectangle. */
              do {
                      /* Get the first cell's contents. */
                      cell = row_data ? _bte_row_data_get (row_data, bidirow->vis2log(i)) : nullptr;
                      /* Find the colors for this cell. */
                      selected = cell_is_selected_vis(i, row);
                      determine_colors(cell, selected, &fore, &back, &deco);
                      rtl = bidirow->vis_is_rtl(i);

                      while (++j < column_count) {
                              /* Retrieve the next cell. */
                              cell = row_data ? _bte_row_data_get (row_data, bidirow->vis2log(j)) : nullptr;
                              /* Resolve attributes to colors where possible and
                               * compare visual attributes to the first character
                               * in this chunk. */
                              selected = cell_is_selected_vis(j, row);
                              determine_colors(cell, selected, &nfore, &nback, &ndeco);
                              nrtl = bidirow->vis_is_rtl(j);
                              if (nback != back || (_bte_debug_on (BTE_DEBUG_BIDI) && nrtl != rtl)) {
                                      break;
                              }
                      }
                      if (back != BTE_DEFAULT_BG257) {
                              bte::color::rgb bg;
                              rgb_from_index<8, 8, 8>(back, bg);
                              m_draw.fill_rectangle(
                                                        i * column_width,
                                                        y,
                                                        (j - i) * column_width,
                                                        row_height,
                                                        &bg, BTE_DRAW_OPAQUE(1.0));
                      }

                      _BTE_DEBUG_IF (BTE_DEBUG_BIDI)if (0) {
                              /* Debug: Highlight RTL letters and RTL rows with a slightly different background. */
                              bte::color::rgb bg;
                              rgb_from_index<8, 8, 8>(back, bg);
                              /* Go halfway towards #C0C0C0. */
                              bg.red   = (bg.red   + 0xC000) / 2;
                              bg.green = (bg.green + 0xC000) / 2;
                              bg.blue  = (bg.blue  + 0xC000) / 2;
                              int y1 = y + round(row_height / 8.);
                              int y2 = y + row_height - round(row_height / 8.);
                              /* Paint the top and bottom eighth of the cell with this more gray background
                               * if the paragraph has a resolved RTL base direction. */
                              if (bidirow->base_is_rtl()) {
                                      m_draw.fill_rectangle(
                                                                i * column_width,
                                                                y,
                                                                (j - i) * column_width,
                                                                y1 - y,
                                                                &bg, BTE_DRAW_OPAQUE(1.0));
                                      m_draw.fill_rectangle(
                                                                i * column_width,
                                                                y2,
                                                                (j - i) * column_width,
                                                                y + row_height - y2,
                                                                &bg, BTE_DRAW_OPAQUE(1.0));
                              }
                              /* Paint the middle three quarters of the cell with this more gray background
                               * if the current character has a resolved RTL direction. */
                              if (rtl) {
                                      m_draw.fill_rectangle(
                                                                i * column_width,
                                                                y1,
                                                                (j - i) * column_width,
                                                                y2 - y1,
                                                                &bg, BTE_DRAW_OPAQUE(1.0));
                              }
                      }

                      /* We'll need to continue at the first cell which didn't
                       * match the first one in this set. */
                      i = j;
              } while (i < column_count);
      }


      /* Render the text.
       * The rect contains the area of the row (enlarged a bit at the top and bottom
       * to allow the text to overdraw a bit), and is moved row-wise in the loop.
       */
      rect = cairo_rectangle_int_t{-m_padding.left,
                                   start_y - cell_overflow_top(),
                                   rect_width,
                                   row_height + cell_overflow_top() + cell_overflow_bottom()};

      for (row = start_row, y = start_y;
           row < end_row;
           row++, y += row_height, rect.y += row_height) {
              /* Check whether we need to draw this row at all */
              if (cairo_region_contains_rectangle(region, &rect) == CAIRO_REGION_OVERLAP_OUT)
                      continue;

              row_data = find_row_data(row);
              if (row_data == NULL__null)
                      continue; /* Skip row. */

              /* Ensure that drawing is restricted to the cell (plus the overdraw area) */
              _bte_draw_autoclip_t clipper{m_draw, &rect};

              bidirow = m_ringview.get_bidirow(row);

              /* Walk the line in logical order.
               * Locate runs of identical attributes within a row, and draw each run using a single draw_cells() call. */
              item_count = 0;
              // FIXME No need for the "< column_count" safety cap once bug 135 is addressed.
              for (lcol = 0; lcol < row_data->len && lcol < column_count; ) {
                      vcol = bidirow->log2vis(lcol);

                      /* Get the character cell's contents. */
                      cell = _bte_row_data_get (row_data, lcol);
                      g_assert(cell != nullptr)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1033
; if (cell != nullptr) _g_boolean_var_1033 = 1; else _g_boolean_var_1033
 = 0; _g_boolean_var_1033; }), 1)) ; else g_assertion_message_expr
 ("BTE", "../src/bte.cc", 8839, ((const char*) (__PRETTY_FUNCTION__
)), "cell != nullptr"); } while (0);

                      nhyperlink = (m_allow_hyperlink && cell->attr.hyperlink_idx != 0);
                      nhilite = (nhyperlink && cell->attr.hyperlink_idx == m_hyperlink_hover_idx) ||
                                (!nhyperlink && regex_match_has_current() && m_match_span.contains(row, lcol));
                      if (cell->c == 0 ||
                              ((cell->c == ' ' || cell->c == '\t') &&  // FIXME '\t' is newly added now, double check
                               cell->attr.has_none(BTE_ATTR_UNDERLINE_MASK((((1U << ((2))) - 1U) << ((((((0) + (4)) + (1)) +
 (1)) + (1))))) |
                                                   BTE_ATTR_STRIKETHROUGH_MASK((((1U << ((1))) - 1U) << (((((((0) + (4)) + (1))
 + (1)) + (1)) + (2))))) |
                                                   BTE_ATTR_OVERLINE_MASK((((1U << ((1))) - 1U) << ((((((((0) + (4)) + (1)
) + (1)) + (1)) + (2)) + (1)))))) &&
                               !nhyperlink &&
                               !nhilite) ||
                          cell->attr.fragment() ||
                          cell->attr.invisible()) {
                              /* Skip empty or fragment cell. */
                              lcol++;
                              continue;
                      }

                      /* Find the colors for this cell. */
                      nattr = cell->attr.attr;
                      selected = cell_is_selected_log(lcol, row);
                      determine_colors(cell, selected, &nfore, &nback, &ndeco);

                      /* See if it no longer fits the run. */
                      if (item_count > 0 &&
                                 (((attr ^ nattr) & (BTE_ATTR_BOLD_MASK((((1U << ((1))) - 1U) << ((((0) + (4)) + (1))))) |
                                                     BTE_ATTR_ITALIC_MASK((((1U << ((1))) - 1U) << (((((0) + (4)) + (1)) +
 (1))))) |
                                                     BTE_ATTR_UNDERLINE_MASK((((1U << ((2))) - 1U) << ((((((0) + (4)) + (1)) +
 (1)) + (1))))) |
                                                     BTE_ATTR_STRIKETHROUGH_MASK((((1U << ((1))) - 1U) << (((((((0) + (4)) + (1))
 + (1)) + (1)) + (2))))) |
                                                     BTE_ATTR_OVERLINE_MASK((((1U << ((1))) - 1U) << ((((((((0) + (4)) + (1)
) + (1)) + (1)) + (2)) + (1))))) |
                                                     BTE_ATTR_BLINK_MASK((((1U << ((1))) - 1U) << ((((((((((0) + (4)) + (
1)) + (1)) + (1)) + (2)) + (1)) + (1)) + (1))))) |
                                                     BTE_ATTR_INVISIBLE_MASK((((1U << ((1))) - 1U) << ((((((((((((0) + (4)) +
 (1)) + (1)) + (1)) + (2)) + (1)) + (1)) + (1)) + (1)) + (1))
))))) ||  // FIXME or just simply "attr != nattr"?
                                  fore != nfore ||
                                  back != nback ||
                                  deco != ndeco ||
                                  hyperlink != nhyperlink ||
                                  hilite != nhilite)) {
                              /* Draw the completed run of cells and start a new one. */
                              draw_cells(items, item_count,
                                         fore, back, deco, FALSE(0), FALSE(0),
                                         attr & attr_mask,
                                         hyperlink, hilite,
                                         column_width, row_height);
                              item_count = 0;
                      }

                      /* Combine with subsequent spacing marks. */
                      bteunistr c = cell->c;
                      j = lcol + cell->attr.columns();
                      if (G_UNLIKELY (lcol == 0 && g_unichar_ismark (_bte_unistr_get_base (cell->c)))(__builtin_expect (__extension__ ({ int _g_boolean_var_1034; if
 (lcol == 0 && g_unichar_ismark (_bte_unistr_get_base
 (cell->c))) _g_boolean_var_1034 = 1; else _g_boolean_var_1034
 = 0; _g_boolean_var_1034; }), 0))) {
                              /* A rare special case: the first cell contains a spacing mark.
                               * Place on top of a NBSP, along with additional spacing marks if any,
                               * and display beginning at offscreen column -1.
                               * Additional spacing marks, if any, will be combined by the loop below. */
                              c = _bte_unistr_append_unistr (0x00A0, cell->c);
                              lcol = -1;
                      }
                      // FIXME No need for the "< column_count" safety cap once bug 135 is addressed.
                      while (j < row_data->len && j < column_count) {
                              /* Combine with subsequent spacing marks. */
                              cell = _bte_row_data_get (row_data, j);
                              if (cell && !cell->attr.fragment() && g_unichar_ismark (_bte_unistr_get_base (cell->c))) {
                                      c = _bte_unistr_append_unistr (c, cell->c);
                                      j += cell->attr.columns();
                              } else {
                                      break;
                              }
                      }

                      attr = nattr;
                      fore = nfore;
                      back = nback;
                      deco = ndeco;
                      hyperlink = nhyperlink;
                      hilite = nhilite;

                      g_assert_cmpint (item_count, <, column_count)do { gint64 __n1 = (item_count), __n2 = (column_count); if (__n1
 < __n2) ; else g_assertion_message_cmpnum ("BTE", "../src/bte.cc"
, 8916, ((const char*) (__PRETTY_FUNCTION__)), "item_count" " "
 "<" " " "column_count", (long double) __n1, "<", (long
 double) __n2, 'i'); } while (0);
                      items[item_count].c = bidirow->vis_get_shaped_char(vcol, c);
                      items[item_count].columns = j - lcol;
                      items[item_count].x = (vcol - (bidirow->vis_is_rtl(vcol) ? items[item_count].columns - 1 : 0)) * column_width;
                      items[item_count].y = y;
                      items[item_count].mirror = bidirow->vis_is_rtl(vcol);
                      items[item_count].box_mirror = !!(row_data->attr.bidi_flags & BTE_BIDI_FLAG_BOX_MIRROR);
                      item_count++;

                      g_assert_cmpint (j, >, lcol)do { gint64 __n1 = (j), __n2 = (lcol); if (__n1 > __n2) ; else
 g_assertion_message_cmpnum ("BTE", "../src/bte.cc", 8925, ((
const char*) (__PRETTY_FUNCTION__)), "j" " " ">" " " "lcol"
, (long double) __n1, ">", (long double) __n2, 'i'); } while
 (0);
                      lcol = j;
              }

              /* Draw the last run of cells in the row. */
              if (item_count > 0) {
                      draw_cells(items, item_count,
                                 fore, back, deco, FALSE(0), FALSE(0),
                                 attr & attr_mask,
                                 hyperlink, hilite,
                                 column_width, row_height);
              }
      }
8938}

8940void
8941Terminal::paint_cursor()
8942{
      bte::view::DrawingContext::TextRequest item;
      bte::grid::row_t drow;
      bte::grid::column_t lcol, vcol;
      int width, height, cursor_width;
      guint fore, back, deco;
bte::color::rgb bg;
int x, y;
gboolean blink, selected, focus;

      //FIXMEchpe this should already be reflected in the m_cursor_blink_state below
if (!m_modes_private.DEC_TEXT_CURSOR())
return;

      if (m_im_preedit_active)
              return;

focus = m_has_focus;
blink = m_cursor_blink_state;

if (focus && !blink)
return;

      lcol = m_screen->cursor.col;
      drow = m_screen->cursor.row;
width = m_cell_width;
height = m_cell_height;

      if (!cursor_is_onscreen())
              return;
      if (CLAMP(lcol, 0, m_column_count - 1)(((lcol) > (m_column_count - 1)) ? (m_column_count - 1) : (
((lcol) < (0)) ? (0) : (lcol))) != lcol)
return;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      /* Find the first cell of the character "under" the cursor.
       * This is for CJK.  For TAB, paint the cursor where it really is. */
      BteRowData const *row_data = find_row_data(drow);
      bte::base::BidiRow const *bidirow = m_ringview.get_bidirow(drow);

      auto cell = find_charcell(lcol, drow);
      while (cell != NULL__null && cell->attr.fragment() && cell->c != '\t' && lcol > 0) {
              lcol--;
              cell = find_charcell(lcol, drow);
}

/* Draw the cursor. */
      vcol = bidirow->log2vis(lcol);
      item.c = (cell && cell->c) ? bidirow->vis_get_shaped_char(vcol, cell->c) : ' ';
item.columns = item.c == '\t' ? 1 : cell ? cell->attr.columns() : 1;
      item.x = (vcol - ((cell && bidirow->vis_is_rtl(vcol)) ? cell->attr.columns() - 1 : 0)) * width;
item.y = row_to_pixel(drow);
      item.mirror = bidirow->vis_is_rtl(vcol);
      item.box_mirror = (row_data && (row_data->attr.bidi_flags & BTE_BIDI_FLAG_BOX_MIRROR));
      auto const attr = cell && cell->c ? cell->attr.attr : 0;

      selected = cell_is_selected_log(lcol, drow);
      determine_cursor_colors(cell, selected, &fore, &back, &deco);
      rgb_from_index<8, 8, 8>(back, bg);

x = item.x;
y = item.y;

      switch (decscusr_cursor_shape()) {

case CursorShape::eIBEAM: {
                      /* Draw at the very left of the cell (before the spacing), even in case of CJK.
                       * IMO (egmont) not overrunning the letter improves readability, vertical movement
                       * looks good (no zigzag even when a somewhat wider glyph that starts filling up
                       * the left spacing, or CJK that begins further to the right is encountered),
                       * and also this is where it looks good if background colors change, including
                       * Shift+arrows highlighting experience in some editors. As per the behavior of
                       * word processors, don't increase the height by the line spacing. */
                      int stem_width;

                      stem_width = (int) (((float) (m_char_ascent + m_char_descent)) * m_cursor_aspect_ratio + 0.5);
                      stem_width = CLAMP (stem_width, BTE_LINE_WIDTH, m_cell_width)(((stem_width) > (m_cell_width)) ? (m_cell_width) : (((stem_width
) < (1)) ? (1) : (stem_width)));

                      /* The I-beam goes to the right edge of the cell if its character has RTL resolved direction. */
                      if (bidirow->vis_is_rtl(vcol))
                              x += item.columns * m_cell_width - stem_width;

                      m_draw.fill_rectangle(
                                               x, y + m_char_padding.top, stem_width, m_char_ascent + m_char_descent,
                                               &bg, BTE_DRAW_OPAQUE(1.0));

                      /* Show the direction of the current character if the paragraph contains a mixture
                       * of directions.
                       * FIXME Do this for the other cursor shapes, too. Need to find a good visual design. */
                      if (focus && bidirow->has_foreign())
                              m_draw.fill_rectangle(
                                                       bidirow->vis_is_rtl(vcol) ? x - stem_width : x + stem_width,
                                                       y + m_char_padding.top,
                                                       stem_width, stem_width,
                                                       &bg, BTE_DRAW_OPAQUE(1.0));
	break;
              }

case CursorShape::eUNDERLINE: {
                      /* The width is at least the overall width of the cell (or two cells) minus the two
                       * half spacings on the two edges. That is, underlines under a CJK are more than twice
                       * as wide as narrow characters in case of letter spacing. Plus, if necessary, the width
                       * is increased to span under the entire glyph. Vertical position is not affected by
                       * line spacing. */

                      int line_height, left, right;

	/* use height (not width) so underline and ibeam will
	 * be equally visible */
                      line_height = (int) (((float) (m_char_ascent + m_char_descent)) * m_cursor_aspect_ratio + 0.5);
                      line_height = CLAMP (line_height, BTE_LINE_WIDTH, m_char_ascent + m_char_descent)(((line_height) > (m_char_ascent + m_char_descent)) ? (m_char_ascent
 + m_char_descent) : (((line_height) < (1)) ? (1) : (line_height
)));

                      left = m_char_padding.left;
                      right = item.columns * m_cell_width - m_char_padding.right;

                      if (cell && cell->c != 0 && cell->c != ' ' && cell->c != '\t') {
                              int l, r;
                              m_draw.get_char_edges(cell->c, cell->attr.columns(), attr, l, r);
                              left = MIN(left, l)(((left) < (l)) ? (left) : (l));
                              right = MAX(right, r)(((right) > (r)) ? (right) : (r));
                      }

                      m_draw.fill_rectangle(
                                               x + left, y + m_cell_height - m_char_padding.bottom - line_height,
                                               right - left, line_height,
                                               &bg, BTE_DRAW_OPAQUE(1.0));
	break;
              }

case CursorShape::eBLOCK:
                      /* Include the spacings in the cursor, see bug 781479 comments 39-44.
                       * Make the cursor even wider if the glyph is wider. */

                      cursor_width = item.columns * width;
                      if (cell && cell->c != 0 && cell->c != ' ' && cell->c != '\t') {
                              int l, r;
                              m_draw.get_char_edges(cell->c, cell->attr.columns(), attr, l /* unused */, r);
                              cursor_width = MAX(cursor_width, r)(((cursor_width) > (r)) ? (cursor_width) : (r));
	}

                      uint32_t const attr_mask = m_allow_bold ? ~0 : ~BTE_ATTR_BOLD_MASK((((1U << ((1))) - 1U) << ((((0) + (4)) + (1)))));

	if (focus) {
		/* just reverse the character under the cursor */
                              m_draw.fill_rectangle(
					     x, y,
                                                       cursor_width, height,
                                                       &bg, BTE_DRAW_OPAQUE(1.0));

                              if (cell && cell->c != 0 && cell->c != ' ' && cell->c != '\t') {
                                      draw_cells(
                                                      &item, 1,
                                                      fore, back, deco, TRUE(!(0)), FALSE(0),
                                                      cell->attr.attr & attr_mask,
                                                      m_allow_hyperlink && cell->attr.hyperlink_idx != 0,
                                                      FALSE(0),
                                                      width,
                                                      height);
		}

	} else {
		/* draw a box around the character */
                              m_draw.draw_rectangle(
					     x - BTE_LINE_WIDTH1,
					     y - BTE_LINE_WIDTH1,
					     cursor_width + 2*BTE_LINE_WIDTH1,
                                                       height + 2*BTE_LINE_WIDTH1,
                                                       &bg, BTE_DRAW_OPAQUE(1.0));
	}

	break;
}
9115}

9117void
9118Terminal::paint_im_preedit_string()
9119{
      int vcol, columns;
      long row;
long width, height;
int i, len;

if (m_im_preedit.empty())
16
←
Assuming the condition is false→
17
←
Taking false branch→
return;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      /* Get the row's BiDi information. */
      row = m_screen->cursor.row;
      if (row < first_displayed_row() || row > last_displayed_row())
18
←
Assuming the condition is false→
19
←
Assuming the condition is false→
20
←
Taking false branch→
              return;
      bte::base::BidiRow const *bidirow = m_ringview.get_bidirow(row);

/* Keep local copies of rendering information. */
width = m_cell_width;
height = m_cell_height;

/* Find out how many columns the pre-edit string takes up. */
columns = get_preedit_width(false);
len = get_preedit_length(false);

/* If the pre-edit string won't fit on the screen if we start
* drawing it at the cursor's position, move it left. */
      vcol = bidirow->log2vis(m_screen->cursor.col);
      if (vcol + columns > m_column_count) {
21
←
Assuming the condition is false→
22
←
Taking false branch→
              vcol = MAX(0, m_column_count - columns)(((0) > (m_column_count - columns)) ? (0) : (m_column_count
 - columns));
}

/* Draw the preedit string, boxed. */
if (len22.1
'len' is > 0
 > 0) {
23
←
Taking true branch→
const char *preedit = m_im_preedit.c_str();
int preedit_cursor;

              auto items = g_new0(bte::view::DrawingContext::TextRequest, len)(bte::view::DrawingContext::TextRequest *) (__extension__ ({ gsize
 __n = (gsize) (len); gsize __s = sizeof (bte::view::DrawingContext
::TextRequest); gpointer __p; if (__s == 1) __p = g_malloc0 (
__n); else if (__builtin_constant_p (__n) && (__s == 0
 || __n <= (9223372036854775807L *2UL+1UL) / __s)) __p = g_malloc0
 (__n * __s); else __p = g_malloc0_n (__n, __s); __p; }));
24
←
Taking false branch→
for (i = columns = 0; i < len; i++) {
25
←
Loop condition is true.  Entering loop body→
26
←
Loop condition is false. Execution continues on line 9167→
	items[i].c = g_utf8_get_char(preedit);
                      items[i].columns = _bte_unichar_width(items[i].c,
                                                            m_utf8_ambiguous_width);
                      items[i].x = (vcol + columns) * width;
	items[i].y = row_to_pixel(m_screen->cursor.row);
	columns += items[i].columns;
	preedit = g_utf8_next_char(preedit)(char *)((preedit) + g_utf8_skip[*(const guchar *)(preedit)]);
}
              if (G_LIKELY(m_clear_background)(__builtin_expect (__extension__ ({ int _g_boolean_var_1035; if
 (m_clear_background) _g_boolean_var_1035 = 1; else _g_boolean_var_1035
 = 0; _g_boolean_var_1035; }), 1))) {
27
←
Assuming field 'm_clear_background' is false→
28
←
Taking false branch→
29
←
Taking false branch→
                      m_draw.clear(
                                      vcol * width,
                                      row_to_pixel(m_screen->cursor.row),
                                      width * columns,
                                      height,
                                      get_color(BTE_DEFAULT_BG257), m_background_alpha);
              }
draw_cells_with_attributes(
30
←
Calling 'Terminal::draw_cells_with_attributes'→
					items, len,
					m_im_preedit_attrs.get(),
					TRUE(!(0)),
					width, height);
preedit_cursor = m_im_preedit_cursor;

if (preedit_cursor >= 0 && preedit_cursor < len) {
                      uint32_t fore, back, deco;
                      bte_color_triple_get(m_color_defaults.attr.colors(), &fore, &back, &deco);

	/* Cursored letter in reverse. */
	draw_cells(
				&items[preedit_cursor], 1,
                                              fore, back, deco,
                                              TRUE(!(0)),  /* clear */
                                              TRUE(!(0)),  /* draw_default_bg */
                                              BTE_ATTR_NONE(0U) | BTE_ATTR_BOXED(1U << (31)),
                                              FALSE(0), /* hyperlink */
                                              FALSE(0), /* hilite */
				width, height);
}
g_free(items);
}
9199}

9201void
9202Terminal::widget_draw(cairo_t *cr)
9203{
      cairo_rectangle_int_t clip_rect;
      cairo_region_t *region;
      int allocated_width, allocated_height;
      int extra_area_for_cursor;
      bool text_blink_enabled_now;
      gint64 now = 0;

      if (!cdk_cairo_get_clip_rectangle (cr, &clip_rect))
1
Assuming the condition is false→
2
←
Taking false branch→
              return;

      _bte_debug_print(BTE_DEBUG_LIFECYCLE, "bte_terminal_draw()\n")do { } while(0);
3
←
Loop condition is false.  Exiting loop→
      _bte_debug_print (BTE_DEBUG_WORK, "+")do { } while(0);
4
←
Loop condition is false.  Exiting loop→
      _bte_debug_print (BTE_DEBUG_UPDATES, "Draw (%d,%d)x(%d,%d)\n",do { } while(0)
5
←
Loop condition is false.  Exiting loop→
                        clip_rect.x, clip_rect.y,do { } while(0)
                        clip_rect.width, clip_rect.height)do { } while(0);

      region = bte_cairo_get_clip_region (cr);
      if (region == NULL__null)
6
←
Assuming 'region' is not equal to NULL→
7
←
Taking false branch→
              return;

      allocated_width = get_allocated_width();
      allocated_height = get_allocated_height();

/* Designate the start of the drawing operation and clear the area. */
m_draw.set_cairo(cr);

      if (G_LIKELY(m_clear_background)(__builtin_expect (__extension__ ({ int _g_boolean_var_1036; if
 (m_clear_background) _g_boolean_var_1036 = 1; else _g_boolean_var_1036
 = 0; _g_boolean_var_1036; }), 1))) {
8
←
Assuming field 'm_clear_background' is false→
9
←
Taking false branch→
10
←
Taking false branch→
              m_draw.clear(0, 0,
                               allocated_width, allocated_height,
                               get_color(BTE_DEFAULT_BG257), m_background_alpha);
      }

      /* Clip vertically, for the sake of smooth scrolling. We want the top and bottom paddings to be unused.
       * Don't clip horizontally so that antialiasing can legally overflow to the right padding. */
      cairo_save(cr);
      cairo_rectangle(cr, 0, m_padding.top, allocated_width, allocated_height - m_padding.top - m_padding.bottom);
      cairo_clip(cr);

      cairo_translate(cr, m_padding.left, m_padding.top);

      /* Transform to view coordinates */
      cairo_region_translate(region, -m_padding.left, -m_padding.top);

      /* Whether blinking text should be visible now */
      m_text_blink_state = true;
      text_blink_enabled_now = (unsigned)m_text_blink_mode & (unsigned)(m_has_focus ? TextBlinkMode::eFOCUSED : TextBlinkMode::eUNFOCUSED);
11
←
Assuming field 'm_has_focus' is false→
12
←
'?' condition is false→
      if (text_blink_enabled_now) {
13
←
Assuming 'text_blink_enabled_now' is false→
14
←
Taking false branch→
              now = g_get_monotonic_time() / 1000;
              if (now % (m_text_blink_cycle * 2) >= m_text_blink_cycle)
                      m_text_blink_state = false;
      }
      /* Painting will flip this if it encounters any cell with blink attribute */
      m_text_to_blink = false;

      /* and now paint them */
      auto const first_row = first_displayed_row();
      draw_rows(m_screen,
                region,
                first_row,
                last_displayed_row() + 1,
                row_to_pixel(first_row),
                m_cell_width,
                m_cell_height);

paint_im_preedit_string();
15
←
Calling 'Terminal::paint_im_preedit_string'→

      cairo_restore(cr);

      /* Re-clip, allowing BTE_LINE_WIDTH more pixel rows for the outline cursor. */
      /* TODOegmont: It's really ugly to do it here. */
      cairo_save(cr);
      extra_area_for_cursor = (decscusr_cursor_shape() == CursorShape::eBLOCK && !m_has_focus) ? BTE_LINE_WIDTH1 : 0;
      cairo_rectangle(cr, 0, m_padding.top - extra_area_for_cursor, allocated_width, allocated_height - m_padding.top - m_padding.bottom + 2 * extra_area_for_cursor);
      cairo_clip(cr);

      cairo_translate(cr, m_padding.left, m_padding.top);

paint_cursor();

cairo_restore(cr);

/* Done with various structures. */
m_draw.set_cairo(nullptr);

      cairo_region_destroy (region);

      /* If painting encountered any cell with blink attribute, we might need to set up a timer.
       * Blinking is implemented using a one-shot (not repeating) timer that keeps getting reinstalled
       * here as long as blinking cells are encountered during (re)painting. This way there's no need
       * for an explicit step to stop the timer when blinking cells are no longer present, this happens
       * implicitly by the timer not getting reinstalled anymore (often after a final unnecessary but
       * harmless repaint). */
      if (G_UNLIKELY (m_text_to_blink && text_blink_enabled_now && !m_text_blink_timer)(__builtin_expect (__extension__ ({ int _g_boolean_var_1037; if
 (m_text_to_blink && text_blink_enabled_now &&
 !m_text_blink_timer) _g_boolean_var_1037 = 1; else _g_boolean_var_1037
 = 0; _g_boolean_var_1037; }), 0)))
              m_text_blink_timer.schedule(m_text_blink_cycle - now % m_text_blink_cycle,
                                          bte::glib::Timer::Priority::eLOW);

      m_invalidated_all = FALSE(0);
9301}

9303/* Handle an expose event by painting the exposed area. */
9304static cairo_region_t *
9305bte_cairo_get_clip_region (cairo_t *cr)
9306{
      cairo_rectangle_list_t *list;
      cairo_region_t *region;
      int i;

      list = cairo_copy_clip_rectangle_list (cr);
      if (list->status == CAIRO_STATUS_CLIP_NOT_REPRESENTABLE) {
              cairo_rectangle_int_t clip_rect;

              cairo_rectangle_list_destroy (list);

              if (!cdk_cairo_get_clip_rectangle (cr, &clip_rect))
                      return NULL__null;
              return cairo_region_create_rectangle (&clip_rect);
      }


      region = cairo_region_create ();
      for (i = list->num_rectangles - 1; i >= 0; --i) {
              cairo_rectangle_t *rect = &list->rectangles[i];
              cairo_rectangle_int_t clip_rect;

              clip_rect.x = floor (rect->x);
              clip_rect.y = floor (rect->y);
              clip_rect.width = ceil (rect->x + rect->width) - clip_rect.x;
              clip_rect.height = ceil (rect->y + rect->height) - clip_rect.y;

              if (cairo_region_union_rectangle (region, &clip_rect) != CAIRO_STATUS_SUCCESS) {
                      cairo_region_destroy (region);
                      region = NULL__null;
                      break;
              }
      }

      cairo_rectangle_list_destroy (list);
      return region;
9342}

9344bool
9345Terminal::widget_mouse_scroll(MouseEvent const& event)
9346{
gdouble v;
gint cnt, i;
int button;

      /* Need to ensure the ringview is updated. */
      ringview_update();

      auto rowcol = confined_grid_coords_from_event(event);

      m_modifiers = event.modifiers();

      switch (event.scroll_direction()) {
      case MouseEvent::ScrollDirection::eUP:
m_mouse_smooth_scroll_delta -= 1.;
_bte_debug_print(BTE_DEBUG_EVENTS, "Scroll up\n")do { } while(0);
break;
      case MouseEvent::ScrollDirection::eDOWN:
m_mouse_smooth_scroll_delta += 1.;
_bte_debug_print(BTE_DEBUG_EVENTS, "Scroll down\n")do { } while(0);
break;
      case MouseEvent::ScrollDirection::eSMOOTH: {
              auto const delta_y = event.scroll_delta_y();
m_mouse_smooth_scroll_delta += delta_y;
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
		"Smooth scroll by %f, delta now at %f\n",do { } while(0)
		delta_y, m_mouse_smooth_scroll_delta)do { } while(0);
break;
      }
default:
break;
}

/* If we're running a mouse-aware application, map the scroll event
* to a button press on buttons four and five. */
if (m_mouse_tracking_mode != MouseTrackingMode::eNONE) {
cnt = m_mouse_smooth_scroll_delta;
if (cnt == 0)
	return true;
m_mouse_smooth_scroll_delta -= cnt;
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
		"Scroll application by %d lines, smooth scroll delta set back to %f\n",do { } while(0)
		cnt, m_mouse_smooth_scroll_delta)do { } while(0);

button = cnt > 0 ? 5 : 4;
if (cnt < 0)
	cnt = -cnt;
for (i = 0; i < cnt; i++) {
	/* Encode the parameters and send them to the app. */
                      feed_mouse_event(rowcol,
                                       button,
                                       false /* not drag */,
                                       false /* not release */);
}
return true;
}

      v = MAX (1., ceil (ctk_adjustment_get_page_increment (m_vadjustment.get()) / 10.))(((1.) > (ceil (ctk_adjustment_get_page_increment (m_vadjustment
.get()) / 10.))) ? (1.) : (ceil (ctk_adjustment_get_page_increment
 (m_vadjustment.get()) / 10.)));
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
	"Scroll speed is %d lines per non-smooth scroll unit\n",do { } while(0)
	(int) v)do { } while(0);
if (m_screen == &m_alternate_screen &&
          m_modes_private.XTERM_ALTBUF_SCROLL()) {
char *normal;
gsize normal_length;

cnt = v * m_mouse_smooth_scroll_delta;
if (cnt == 0)
	return true;
m_mouse_smooth_scroll_delta -= cnt / v;
_bte_debug_print(BTE_DEBUG_EVENTS,do { } while(0)
		"Scroll by %d lines, smooth scroll delta set back to %f\n",do { } while(0)
		cnt, m_mouse_smooth_scroll_delta)do { } while(0);

/* In the alternate screen there is no scrolling,
 * so fake a few cursor keystrokes. */

_bte_keymap_map (
		cnt > 0 ? CDK_KEY_Down0xff54 : CDK_KEY_Up0xff52,
		m_modifiers,
                              m_modes_private.DEC_APPLICATION_CURSOR_KEYS(),
                              m_modes_private.DEC_APPLICATION_KEYPAD(),
		&normal,
		&normal_length);
if (cnt < 0)
	cnt = -cnt;
for (i = 0; i < cnt; i++) {
	send_child({normal, normal_length});
}
g_free (normal);

              return true;
} else {
/* Perform a history scroll. */
double dcnt = m_screen->scroll_delta + v * m_mouse_smooth_scroll_delta;
queue_adjustment_value_changed_clamped(dcnt);
m_mouse_smooth_scroll_delta = 0;

              return true;
}

      return true;
9448}

9450bool
9451Terminal::set_audible_bell(bool setting)
9452{
      if (setting == m_audible_bell)
              return false;

m_audible_bell = setting;
      return true;
9458}

9460bool
9461Terminal::set_text_blink_mode(TextBlinkMode setting)
9462{
      if (setting == m_text_blink_mode)
              return false;

      m_text_blink_mode = setting;
      invalidate_all();

      return true;
9470}

9472bool
9473Terminal::set_enable_bidi(bool setting)
9474{
      if (setting == m_enable_bidi)
              return false;

      m_enable_bidi = setting;
      m_ringview.invalidate();
      invalidate_all();

      /* Chances are that we can free up some BiDi/shaping buffers that we
       * won't need for a while. */
      if (!setting)
              m_ringview.pause();

      return true;
9488}

9490bool
9491Terminal::set_enable_shaping(bool setting)
9492{
      if (setting == m_enable_shaping)
              return false;

      m_enable_shaping = setting;
      m_ringview.invalidate();
      invalidate_all();

      /* Chances are that we can free up some BiDi/shaping buffers that we
       * won't need for a while. */
      if (!setting)
              m_ringview.pause();

      return true;
9506}

9508bool
9509Terminal::set_allow_bold(bool setting)
9510{
      if (setting == m_allow_bold)
              return false;

m_allow_bold = setting;
invalidate_all();

      return true;
9518}

9520bool
9521Terminal::set_bold_is_bright(bool setting)
9522{
      if (setting == m_bold_is_bright)
              return false;

m_bold_is_bright = setting;
invalidate_all();

      return true;
9530}

9532bool
9533Terminal::set_allow_hyperlink(bool setting)
9534{
      if (setting == m_allow_hyperlink)
              return false;

      if (setting == false) {
              m_hyperlink_hover_idx = _bte_ring_get_hyperlink_at_position(m_screen->row_data, -1, -1, true, NULL__null);
              g_assert (m_hyperlink_hover_idx == 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1038
; if (m_hyperlink_hover_idx == 0) _g_boolean_var_1038 = 1; else
 _g_boolean_var_1038 = 0; _g_boolean_var_1038; }), 1)) ; else
 g_assertion_message_expr ("BTE", "../src/bte.cc", 9540, ((const
 char*) (__PRETTY_FUNCTION__)), "m_hyperlink_hover_idx == 0")
; } while (0);
              m_hyperlink_hover_uri = NULL__null;
              emit_hyperlink_hover_uri_changed(NULL__null);  /* FIXME only emit if really changed */
              m_defaults.attr.hyperlink_idx = _bte_ring_get_hyperlink_idx(m_screen->row_data, NULL__null);
              g_assert (m_defaults.attr.hyperlink_idx == 0)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_1039
; if (m_defaults.attr.hyperlink_idx == 0) _g_boolean_var_1039
 = 1; else _g_boolean_var_1039 = 0; _g_boolean_var_1039; }), 1
)) ; else g_assertion_message_expr ("BTE", "../src/bte.cc", 9544
, ((const char*) (__PRETTY_FUNCTION__)), "m_defaults.attr.hyperlink_idx == 0"
); } while (0);
      }

      m_allow_hyperlink = setting;
      invalidate_all();

      return true;
9551}

9553bool
9554Terminal::set_scroll_on_output(bool scroll)
9555{
      if (scroll == m_scroll_on_output)
              return false;

      m_scroll_on_output = scroll;
      return true;
9561}

9563bool
9564Terminal::set_scroll_on_keystroke(bool scroll)
9565{
      if (scroll == m_scroll_on_keystroke)
              return false;

      m_scroll_on_keystroke = scroll;
      return true;
9571}

9573bool
9574Terminal::set_rewrap_on_resize(bool rewrap)
9575{
      if (rewrap == m_rewrap_on_resize)
              return false;

      m_rewrap_on_resize = rewrap;
      return true;
9581}

9583void
9584Terminal::update_cursor_blinks()
9585{
      bool blink = false;

      switch (decscusr_cursor_blink()) {
      case CursorBlinkMode::eSYSTEM:
              gboolean v;
              g_object_get(ctk_widget_get_settings(m_widget),
                                                   "ctk-cursor-blink",
                                                   &v, nullptr);
              blink = v != FALSE(0);
              break;
      case CursorBlinkMode::eON:
              blink = true;
              break;
      case CursorBlinkMode::eOFF:
              blink = false;
              break;
      }

if (m_cursor_blinks == blink)
return;

m_cursor_blinks = blink;
check_cursor_blink();
9609}

9611bool
9612Terminal::set_cursor_blink_mode(CursorBlinkMode mode)
9613{
      if (mode == m_cursor_blink_mode)
              return false;

      m_cursor_blink_mode = mode;
      update_cursor_blinks();

      return true;
9621}

9623bool
9624Terminal::set_cursor_shape(CursorShape shape)
9625{
      if (shape == m_cursor_shape)
              return false;

      m_cursor_shape = shape;
invalidate_cursor_once();

      return true;
9633}

9635/* DECSCUSR set cursor style */
9636bool
9637Terminal::set_cursor_style(CursorStyle style)
9638{
      if (m_cursor_style == style)
              return false;

      m_cursor_style = style;
      update_cursor_blinks();
      /* and this will also make cursor shape match the DECSCUSR style */
      invalidate_cursor_once();

      return true;
9648}

9650/*
* Terminal::decscusr_cursor_blink:
*
* Returns the cursor blink mode set by DECSCUSR. If DECSCUSR was never
* called, or it set the blink mode to terminal default, this returns the
* value set via API or in dconf. Internal use only.
*
* Return value: cursor blink mode
*/
9659Terminal::CursorBlinkMode
9660Terminal::decscusr_cursor_blink() const noexcept
9661{
      switch (m_cursor_style) {
      default:
      case CursorStyle::eTERMINAL_DEFAULT:
              return m_cursor_blink_mode;
      case CursorStyle::eBLINK_BLOCK:
      case CursorStyle::eBLINK_UNDERLINE:
      case CursorStyle::eBLINK_IBEAM:
              return CursorBlinkMode::eON;
      case CursorStyle::eSTEADY_BLOCK:
      case CursorStyle::eSTEADY_UNDERLINE:
      case CursorStyle::eSTEADY_IBEAM:
              return CursorBlinkMode::eOFF;
      }
9675}

9677/*
* Terminal::decscusr_cursor_shape:
* @terminal: a #BteTerminal
*
* Returns the cursor shape set by DECSCUSR. If DECSCUSR was never called,
* or it set the cursor shape to terminal default, this returns the value
* set via API. Internal use only.
*
* Return value: cursor shape
*/
9687Terminal::CursorShape
9688Terminal::decscusr_cursor_shape() const noexcept
9689{
      switch (m_cursor_style) {
      default:
      case CursorStyle::eTERMINAL_DEFAULT:
              return m_cursor_shape;
      case CursorStyle::eBLINK_BLOCK:
      case CursorStyle::eSTEADY_BLOCK:
              return CursorShape::eBLOCK;
      case CursorStyle::eBLINK_UNDERLINE:
      case CursorStyle::eSTEADY_UNDERLINE:
              return CursorShape::eUNDERLINE;
      case CursorStyle::eBLINK_IBEAM:
      case CursorStyle::eSTEADY_IBEAM:
              return CursorShape::eIBEAM;
      }
9704}

9706bool
9707Terminal::set_scrollback_lines(long lines)
9708{
      glong low, high, next;
      double scroll_delta;
BteScreen *scrn;

if (lines < 0)
lines = G_MAXLONG9223372036854775807L;

9716#if 0
      /* FIXME: this breaks the scrollbar range, bug #562511 */
      if (lines == m_scrollback_lines)
              return false;
9720#endif

_bte_debug_print (BTE_DEBUG_MISC,do { } while(0)
	"Setting scrollback lines to %ld\n", lines)do { } while(0);

m_scrollback_lines = lines;

      /* The main screen gets the full scrollback buffer. */
      scrn = &m_normal_screen;
      lines = MAX (lines, m_row_count)(((lines) > (m_row_count)) ? (lines) : (m_row_count));
      next = MAX (m_screen->cursor.row + 1,(((m_screen->cursor.row + 1) > (_bte_ring_next (scrn->
row_data))) ? (m_screen->cursor.row + 1) : (_bte_ring_next
 (scrn->row_data)))
                  _bte_ring_next (scrn->row_data))(((m_screen->cursor.row + 1) > (_bte_ring_next (scrn->
row_data))) ? (m_screen->cursor.row + 1) : (_bte_ring_next
 (scrn->row_data)));
      _bte_ring_resize (scrn->row_data, lines);
      low = _bte_ring_delta (scrn->row_data);
      high = lines + MIN (G_MAXLONG - lines, low - m_row_count + 1)(((9223372036854775807L - lines) < (low - m_row_count + 1)
) ? (9223372036854775807L - lines) : (low - m_row_count + 1));
      scrn->insert_delta = CLAMP (scrn->insert_delta, low, high)(((scrn->insert_delta) > (high)) ? (high) : (((scrn->
insert_delta) < (low)) ? (low) : (scrn->insert_delta)));
      scrn->scroll_delta = CLAMP (scrn->scroll_delta, low, scrn->insert_delta)(((scrn->scroll_delta) > (scrn->insert_delta)) ? (scrn
->insert_delta) : (((scrn->scroll_delta) < (low)) ? (
low) : (scrn->scroll_delta)));
      next = MIN (next, scrn->insert_delta + m_row_count)(((next) < (scrn->insert_delta + m_row_count)) ? (next)
 : (scrn->insert_delta + m_row_count));
      if (_bte_ring_next (scrn->row_data) > next){
              _bte_ring_shrink (scrn->row_data, next - low);
      }

      /* The alternate scrn isn't allowed to scroll at all. */
      scrn = &m_alternate_screen;
      _bte_ring_resize (scrn->row_data, m_row_count);
      scrn->scroll_delta = _bte_ring_delta (scrn->row_data);
      scrn->insert_delta = _bte_ring_delta (scrn->row_data);
      if (_bte_ring_next (scrn->row_data) > scrn->insert_delta + m_row_count){
              _bte_ring_shrink (scrn->row_data, m_row_count);
      }

/* Adjust the scrollbar to the new location. */
/* Hack: force a change in scroll_delta even if the value remains, so that
  bte_term_q_adj_val_changed() doesn't shortcut to no-op, see bug 676075. */
      scroll_delta = m_screen->scroll_delta;
m_screen->scroll_delta = -1;
queue_adjustment_value_changed(scroll_delta);
adjust_adjustments_full();

      return true;
9760}

9762bool
9763Terminal::set_backspace_binding(EraseMode binding)
9764{
      if (binding == m_backspace_binding)
              return false;

m_backspace_binding = binding;
      return true;
9770}

9772bool
9773Terminal::set_delete_binding(EraseMode binding)
9774{
      if (binding == m_delete_binding)
              return false;

m_delete_binding = binding;
      return true;
9780}

9782bool
9783Terminal::set_mouse_autohide(bool autohide)
9784{
      if (autohide == m_mouse_autohide)
              return false;

m_mouse_autohide = autohide;

      if (m_mouse_cursor_autohidden) {
              hyperlink_hilite_update();
              match_hilite_update();
              apply_mouse_cursor();
      }
      return true;
9796}

9798void
9799Terminal::reset_decoder()
9800{
      switch (data_syntax()) {
      case DataSyntax::eECMA48_UTF8:
              m_utf8_decoder.reset();
              break;

9806#ifdef WITH_ICU
      case DataSyntax::eECMA48_PCTERM:
              m_converter->decoder().reset();
              break;
9810#endif

      default:
              g_assert_not_reached()do { g_assertion_message_expr ("BTE", "../src/bte.cc", 9813, (
(const char*) (__PRETTY_FUNCTION__)), __null); } while (0);
      }
9815}

9817/*
* Terminal::reset:
* @clear_tabstops: whether to reset tabstops
* @clear_history: whether to empty the terminal's scrollback buffer
*
* Resets as much of the terminal's internal state as possible, discarding any
* unprocessed input data, resetting character attributes, cursor state,
* national character set state, status line, terminal modes (insert/delete),
* selection state, and encoding.
*
*/
9828void
9829Terminal::reset(bool clear_tabstops,
                        bool clear_history,
                        bool from_api)
9832{
      if (from_api && !m_input_enabled)
              return;

      auto const freezer = bte::glib::FreezeObjectNotify{m_terminal};

      m_bell_pending = false;

/* Clear the output buffer. */
_bte_byte_array_clear(m_outgoing)g_byte_array_set_size (m_outgoing, 0);

/* Reset charset substitution state. */

      /* Reset decoder */
      reset_decoder();

      /* Reset parser */
      m_parser.reset();
      m_last_graphic_character = 0;

      /* Reset modes */
      m_modes_ecma.reset();
      m_modes_private.clear_saved();
      m_modes_private.reset();

      /* Reset tabstops */
      if (clear_tabstops) {
              m_tabstops.reset();
      }

      /* Window title stack */
      if (clear_history) {
              m_window_title_stack.clear();
      }

      update_mouse_protocol();

/* Reset the color palette. Only the 256 indexed colors, not the special ones, as per xterm. */
for (int i = 0; i < 256; i++)
m_palette[i].sources[BTE_COLOR_SOURCE_ESCAPE0].is_set = FALSE(0);
/* Reset the default attributes.  Reset the alternate attribute because
* it's not a real attribute, but we need to treat it as one here. */
      reset_default_attributes(true);
      /* Reset charset modes. */
      m_character_replacements[0] = BTE_CHARACTER_REPLACEMENT_NONE;
      m_character_replacements[1] = BTE_CHARACTER_REPLACEMENT_NONE;
      m_character_replacement = &m_character_replacements[0];
/* Clear the scrollback buffers and reset the cursors. Switch to normal screen. */
if (clear_history) {
              m_screen = &m_normal_screen;
              m_normal_screen.scroll_delta = m_normal_screen.insert_delta =
                      _bte_ring_reset(m_normal_screen.row_data);
              m_normal_screen.cursor.row = m_normal_screen.insert_delta;
              m_normal_screen.cursor.col = 0;
              m_alternate_screen.scroll_delta = m_alternate_screen.insert_delta =
                      _bte_ring_reset(m_alternate_screen.row_data);
              m_alternate_screen.cursor.row = m_alternate_screen.insert_delta;
              m_alternate_screen.cursor.col = 0;
              /* Adjust the scrollbar to the new location. */
              /* Hack: force a change in scroll_delta even if the value remains, so that
                 bte_term_q_adj_val_changed() doesn't shortcut to no-op, see bug 730599. */
              m_screen->scroll_delta = -1;
              queue_adjustment_value_changed(m_screen->insert_delta);
adjust_adjustments_full();
}
      /* DECSCUSR cursor style */
      set_cursor_style(CursorStyle::eTERMINAL_DEFAULT);
/* Reset restricted scrolling regions, leave insert mode, make
* the cursor visible again. */
      m_scrolling_restricted = FALSE(0);
      /* Reset the visual bits of selection on hard reset, see bug 789954. */
      if (clear_history) {
              deselect_all();
              stop_autoscroll();  /* Required before setting m_selecting to false, see #105. */
              m_selecting = FALSE(0);
              m_selecting_had_delta = FALSE(0);
              m_selection_origin = m_selection_last = { -1, -1, 1 };
              m_selection_resolved.clear();
      }

/* Reset mouse motion events. */
      m_mouse_pressed_buttons = 0;
      m_mouse_handled_buttons = 0;
m_mouse_last_position = bte::view::coords(-1, -1);
m_mouse_smooth_scroll_delta = 0.;
/* Clear modifiers. */
m_modifiers = 0;
      /* Reset the saved cursor. */
      save_cursor(&m_normal_screen);
      save_cursor(&m_alternate_screen);
      /* BiDi */
      m_bidi_rtl = FALSE(0);
/* Cause everything to be redrawn (or cleared). */
invalidate_all();

      /* Reset XTerm window controls */
      m_xterm_wm_iconified = false;
9929}

9931void
9932Terminal::unset_pty(bool notify_widget)
9933{
      /* This may be called from inside or from widget,
       * and must notify the widget if not called from it.
       */

      disconnect_pty_read();
      disconnect_pty_write();

      m_child_exited_eos_wait_timer.abort();

      /* Clear incoming and outgoing queues */
      m_input_bytes = 0;
      m_incoming_queue = {};
      _bte_byte_array_clear(m_outgoing)g_byte_array_set_size (m_outgoing, 0);

      stop_processing(this); // FIXMEchpe only if m_incoming_queue.empty() !!!

      reset_decoder();

      m_pty.reset();

      if (notify_widget && widget())
              widget()->unset_pty();
9956}

9958bool
9959Terminal::set_pty(bte::base::Pty *new_pty)
9960{
      if (pty().get() == new_pty)
              return false;

      if (pty()) {
              unset_pty(false /* don't notify widget */);
      }

      m_pty = bte::base::make_ref(new_pty);
      if (!new_pty)
              return true;

      set_size(m_column_count, m_row_count);

      if (!pty()->set_utf8(data_syntax() == DataSyntax::eECMA48_UTF8)) {
              // nothing we can do here
      }

      /* Open channels to listen for input on. */
      connect_pty_read();

      return true;
9982}

9984bool
9985Terminal::terminate_child() noexcept
9986{
if (m_pty_pid == -1)
              return false;

      auto pgrp = getpgid(m_pty_pid);
      if (pgrp != -1 && pgrp != getpgid(getpid())) {
              kill(-pgrp, SIGHUP1);
      }

      kill(m_pty_pid, SIGHUP1);
      m_pty_pid = -1;

      return true;
9999}

10001/* We need this bit of glue to ensure that accessible objects will always
* get signals. */
10003void
10004Terminal::subscribe_accessible_events()
10005{
10006#ifdef WITH_A11Y
m_accessible_emit = true;
10008#endif
10009}

10011void
10012Terminal::select_text(bte::grid::column_t start_col,
                              bte::grid::row_t start_row,
                              bte::grid::column_t end_col,
                              bte::grid::row_t end_row)
10016{
deselect_all();

m_selection_type = SelectionType::eCHAR;
m_selecting_had_delta = true;
      m_selection_resolved.set ({ start_row, start_col },
                                { end_row, end_col });
      widget_copy(BTE_SELECTION_PRIMARY, BTE_FORMAT_TEXT);
emit_selection_changed();

      invalidate_rows(start_row, end_row);
10027}

10029void
10030Terminal::select_empty(bte::grid::column_t col,
                               bte::grid::row_t row)
10032{
      select_text(col, row, col, row);
10034}

10036static void
10037remove_process_timeout_source(void)
10038{
if (process_timeout_tag == 0)
              return;

      _bte_debug_print(BTE_DEBUG_TIMEOUT, "Removing process timeout\n")do { } while(0);
      g_source_remove (process_timeout_tag);
      process_timeout_tag = 0;
10045}

10047static void
10048add_update_timeout(bte::terminal::Terminal* that)
10049{
if (update_timeout_tag == 0) {
_bte_debug_print (BTE_DEBUG_TIMEOUT,do { } while(0)
		"Starting update timeout\n")do { } while(0);
update_timeout_tag =
	g_timeout_add_full (CDK_PRIORITY_REDRAW(100 + 20),
			BTE_UPDATE_TIMEOUT15,
			update_timeout, NULL__null,
			NULL__null);
}
if (!in_process_timeout) {
              remove_process_timeout_source();
      }
if (that->m_active_terminals_link == nullptr) {
_bte_debug_print (BTE_DEBUG_TIMEOUT,do { } while(0)
		"Adding terminal to active list\n")do { } while(0);
that->m_active_terminals_link = g_active_terminals =
	g_list_prepend(g_active_terminals, that);
}
10068}

10070void
10071Terminal::reset_update_rects()
10072{
      g_array_set_size(m_update_rects, 0);
m_invalidated_all = FALSE(0);
10075}

10077static bool
10078remove_from_active_list(bte::terminal::Terminal* that)
10079{
if (that->m_active_terminals_link == nullptr ||
          that->m_update_rects->len != 0)
              return false;

      _bte_debug_print(BTE_DEBUG_TIMEOUT, "Removing terminal from active list\n")do { } while(0);
      g_active_terminals = g_list_delete_link(g_active_terminals, that->m_active_terminals_link);
      that->m_active_terminals_link = nullptr;
      return true;
10088}

10090static void
10091stop_processing(bte::terminal::Terminal* that)
10092{
      if (!remove_from_active_list(that))
              return;

      if (g_active_terminals != nullptr)
              return;

      if (!in_process_timeout) {
              remove_process_timeout_source();
      }
      if (in_update_timeout == FALSE(0) &&
          update_timeout_tag != 0) {
              _bte_debug_print(BTE_DEBUG_TIMEOUT, "Removing update timeout\n")do { } while(0);
              g_source_remove (update_timeout_tag);
              update_timeout_tag = 0;
      }
10108}

10110static void
10111remove_update_timeout(bte::terminal::Terminal* that)
10112{
that->reset_update_rects();
      stop_processing(that);
10115}

10117static void
10118add_process_timeout(bte::terminal::Terminal* that)
10119{
_bte_debug_print(BTE_DEBUG_TIMEOUT,do { } while(0)
	"Adding terminal to active list\n")do { } while(0);
that->m_active_terminals_link = g_active_terminals =
g_list_prepend(g_active_terminals, that);
if (update_timeout_tag == 0 &&
	process_timeout_tag == 0) {
_bte_debug_print(BTE_DEBUG_TIMEOUT,do { } while(0)
		"Starting process timeout\n")do { } while(0);
process_timeout_tag =
	g_timeout_add (BTE_DISPLAY_TIMEOUT10,
			process_timeout, NULL__null);
}
10132}

10134void
10135Terminal::start_processing()
10136{
if (!is_processing())
add_process_timeout(this);
10139}

10141void
10142Terminal::emit_pending_signals()
10143{
      auto const freezer = bte::glib::FreezeObjectNotify{m_terminal};

emit_adjustment_changed();

if (m_window_title_changed) {
              if (m_window_title != m_window_title_pending) {
                      m_window_title.swap(m_window_title_pending);

                      _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                                       "Emitting `window-title-changed'.\n")do { } while(0);
                      g_signal_emit(freezer.get(), signals[SIGNAL_WINDOW_TITLE_CHANGED], 0);
                      g_object_notify_by_pspec(freezer.get(), pspecs[PROP_WINDOW_TITLE]);
              }

              m_window_title_pending.clear();
              m_window_title_changed = false;
}

if (m_icon_title_changed) {
              if (m_icon_title != m_icon_title_pending) {
                      m_icon_title.swap(m_icon_title_pending);

                      _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                                       "Emitting `icon-title-changed'.\n")do { } while(0);
                      g_signal_emit(freezer.get(), signals[SIGNAL_ICON_TITLE_CHANGED], 0);
                      g_object_notify_by_pspec(freezer.get(), pspecs[PROP_ICON_TITLE]);
              }

m_icon_title_pending.clear();
m_icon_title_changed = false;
}

if (m_current_directory_uri_changed) {
              if (m_current_directory_uri != m_current_directory_uri_pending) {
                      m_current_directory_uri.swap(m_current_directory_uri_pending);

                      _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                                       "Emitting `current-directory-uri-changed'.\n")do { } while(0);
                      g_signal_emit(freezer.get(), signals[SIGNAL_CURRENT_DIRECTORY_URI_CHANGED], 0);
                      g_object_notify_by_pspec(freezer.get(), pspecs[PROP_CURRENT_DIRECTORY_URI]);
              }

              m_current_directory_uri_pending.clear();
              m_current_directory_uri_changed = false;
      }

      if (m_current_file_uri_changed) {
              if (m_current_file_uri != m_current_file_uri_pending) {
                      m_current_file_uri.swap(m_current_file_uri_pending);

                      _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                                       "Emitting `current-file-uri-changed'.\n")do { } while(0);
                      g_signal_emit(freezer.get(), signals[SIGNAL_CURRENT_FILE_URI_CHANGED], 0);
                      g_object_notify_by_pspec(freezer.get(), pspecs[PROP_CURRENT_FILE_URI]);
              }

              m_current_file_uri_pending.clear();
              m_current_file_uri_changed = false;
      }

/* Flush any pending "inserted" signals. */

      if (m_cursor_moved_pending) {
              _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                               "Emitting `cursor-moved'.\n")do { } while(0);
              g_signal_emit(freezer.get(), signals[SIGNAL_CURSOR_MOVED], 0);
              m_cursor_moved_pending = false;
      }
      if (m_text_modified_flag) {
              _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                               "Emitting buffered `text-modified'.\n")do { } while(0);
              emit_text_modified();
              m_text_modified_flag = false;
      }
      if (m_text_inserted_flag) {
              _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                               "Emitting buffered `text-inserted'\n")do { } while(0);
              emit_text_inserted();
              m_text_inserted_flag = false;
      }
      if (m_text_deleted_flag) {
              _bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
                               "Emitting buffered `text-deleted'\n")do { } while(0);
              emit_text_deleted();
              m_text_deleted_flag = false;
}
if (m_contents_changed_pending) {
              /* Update hyperlink and dingus match set. */
match_contents_clear();
if (m_mouse_cursor_over_widget) {
                      hyperlink_hilite_update();
                      match_hilite_update();
}

_bte_debug_print(BTE_DEBUG_SIGNALS,do { } while(0)
		"Emitting `contents-changed'.\n")do { } while(0);
g_signal_emit(m_terminal, signals[SIGNAL_CONTENTS_CHANGED], 0);
m_contents_changed_pending = false;
}
      if (m_bell_pending) {
              auto const timestamp = g_get_monotonic_time();
              if ((timestamp - m_bell_timestamp) >= BTE_BELL_MINIMUM_TIME_DIFFERENCE(100000)) {
                      beep();
                      emit_bell();

                      m_bell_timestamp = timestamp;
               }

              m_bell_pending = false;
      }

      auto const eos = m_eos_pending;
      if (m_eos_pending) {
              queue_eof();
              m_eos_pending = false;

              unset_pty();
      }

      if (m_child_exited_after_eos_pending && eos) {
              /* The signal handler could destroy the terminal, so send the signal on idle */
              queue_child_exited();
              m_child_exited_after_eos_pending = false;
      }
10268}

10270void
10271Terminal::time_process_incoming()
10272{
g_timer_reset(process_timer);
process_incoming();
auto elapsed = g_timer_elapsed(process_timer, NULL__null) * 1000;
gssize target = BTE_MAX_PROCESS_TIME100 / elapsed * m_input_bytes;
m_max_input_bytes = (m_max_input_bytes + target) / 2;
10278}

10280bool
10281Terminal::process(bool emit_adj_changed)
10282{
      if (pty()) {
              if (m_pty_input_active ||
                  m_pty_input_source == 0) {
                      m_pty_input_active = false;
                      /* Do one read directly. FIXMEchpe: Why? */
                      pty_io_read(pty()->fd(), G_IO_IN);
              }
              connect_pty_read();
      }
      if (emit_adj_changed)
              emit_adjustment_changed();

      bool is_active = !m_incoming_queue.empty();
      if (is_active) {
              if (BTE_MAX_PROCESS_TIME100) {
                      time_process_incoming();
              } else {
                      process_incoming();
              }
              m_input_bytes = 0;
      } else
              emit_pending_signals();

      return is_active;
10307}


10310/* We need to keep a reference to the terminals in the
* g_active_terminals list while iterating over it, since
* in some language bindings the callbacks we emit
* during processing may cause their GC to run, causing
* later elements in this list to be removed from the list.
* See issue bte#270.
*/

10318static void
10319unref_active_terminals(GList* list)
10320{
      g_list_free_full(list, GDestroyNotify(g_object_unref));
10322}

10324static auto
10325ref_active_terminals() noexcept
10326{
      GList* list = nullptr;
      for (auto l = g_active_terminals; l != nullptr; l = l->next) {
              auto that = reinterpret_cast<bte::terminal::Terminal*>(l->data);
              list = g_list_prepend(list, g_object_ref(that->bte_terminal()));
      }

      return std::unique_ptr<GList, decltype(&unref_active_terminals)>{list, &unref_active_terminals};
10334}

10336/* This function is called after DISPLAY_TIMEOUT ms.
* It makes sure initial output is never delayed by more than DISPLAY_TIMEOUT
*/
10339static gboolean
10340process_timeout (gpointer data) noexcept
10341try
10342{
GList *l, *next;
gboolean again;

in_process_timeout = TRUE(!(0));

_bte_debug_print (BTE_DEBUG_WORK, "<")do { } while(0);
_bte_debug_print (BTE_DEBUG_TIMEOUT,do { } while(0)
                        "Process timeout:  %d active\n",do { } while(0)
                        g_list_length(g_active_terminals))do { } while(0);

      auto death_grip = ref_active_terminals();

for (l = g_active_terminals; l != NULL__null; l = next) {
auto that = reinterpret_cast<bte::terminal::Terminal*>(l->data);
bool active;

next = l->next;

if (l != g_active_terminals) {
	_bte_debug_print (BTE_DEBUG_WORK, "T")do { } while(0);
}

              // FIXMEchpe find out why we don't emit_adjustment_changed() here!!
              active = that->process(false);

if (!active) {
                      remove_from_active_list(that);
}
}

_bte_debug_print (BTE_DEBUG_WORK, ">")do { } while(0);

if (g_active_terminals != nullptr && update_timeout_tag == 0) {
again = TRUE(!(0));
} else {
_bte_debug_print(BTE_DEBUG_TIMEOUT,do { } while(0)
		"Stopping process timeout\n")do { } while(0);
process_timeout_tag = 0;
again = FALSE(0);
}

in_process_timeout = FALSE(0);

if (again) {
/* Force us to relinquish the CPU as the child is running
 * at full tilt and making us run to keep up...
 */
g_usleep (0);
} else if (update_timeout_tag == 0) {
/* otherwise free up memory used to capture incoming data */
              bte::base::Chunk::prune();
}

return again;
10397}
10398catch (...)
10399{
      bte::log_exception();
      return true; // false?
10402}

10404bool
10405Terminal::invalidate_dirty_rects_and_process_updates()
10406{
      if (G_UNLIKELY(!widget_realized())(__builtin_expect (__extension__ ({ int _g_boolean_var_1040; if
 (!widget_realized()) _g_boolean_var_1040 = 1; else _g_boolean_var_1040
 = 0; _g_boolean_var_1040; }), 0)))
              return false;

if (G_UNLIKELY (!m_update_rects->len)(__builtin_expect (__extension__ ({ int _g_boolean_var_1041; if
 (!m_update_rects->len) _g_boolean_var_1041 = 1; else _g_boolean_var_1041
 = 0; _g_boolean_var_1041; }), 0)))
return false;

      auto region = cairo_region_create();
      auto n_rects = m_update_rects->len;
      for (guint i = 0; i < n_rects; i++) {
              cairo_rectangle_int_t *rect = &g_array_index(m_update_rects, cairo_rectangle_int_t, i)(((cairo_rectangle_int_t*) (void *) (m_update_rects)->data
) [(i)]);
              cairo_region_union_rectangle(region, rect);
}
      g_array_set_size(m_update_rects, 0);
m_invalidated_all = false;

      auto allocation = get_allocated_rect();
      cairo_region_translate(region,
                             allocation.x + m_padding.left,
                             allocation.y + m_padding.top);

/* and perform the merge with the window visible area */
      ctk_widget_queue_draw_region(m_widget, region);
cairo_region_destroy (region);

return true;
10432}

10434static gboolean
10435update_repeat_timeout (gpointer data)
10436{
GList *l, *next;
bool again;

in_update_timeout = TRUE(!(0));

_bte_debug_print (BTE_DEBUG_WORK, "[")do { } while(0);
_bte_debug_print (BTE_DEBUG_TIMEOUT,do { } while(0)
                        "Repeat timeout:  %d active\n",do { } while(0)
                        g_list_length(g_active_terminals))do { } while(0);

      auto death_grip = ref_active_terminals();

for (l = g_active_terminals; l != NULL__null; l = next) {
auto that = reinterpret_cast<bte::terminal::Terminal*>(l->data);

              next = l->next;

if (l != g_active_terminals) {
	_bte_debug_print (BTE_DEBUG_WORK, "T")do { } while(0);
}

              that->process(true);

again = that->invalidate_dirty_rects_and_process_updates();
if (!again) {
                      remove_from_active_list(that);
}
}

_bte_debug_print (BTE_DEBUG_WORK, "]")do { } while(0);

/* We only stop the timer if no update request was received in this
       * past cycle.  Technically, always stop this timer object and maybe
       * reinstall a new one because we need to delay by the amount of time
       * it took to repaint the screen: bug 730732.
*/
if (g_active_terminals == nullptr) {
_bte_debug_print(BTE_DEBUG_TIMEOUT,do { } while(0)
		"Stopping update timeout\n")do { } while(0);
update_timeout_tag = 0;
again = false;
      } else {
              update_timeout_tag =
                      g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE200,
                                          BTE_UPDATE_REPEAT_TIMEOUT30,
                                          update_repeat_timeout, NULL__null,
                                          NULL__null);
              again = true;
}

in_update_timeout = FALSE(0);

if (again) {
/* Force us to relinquish the CPU as the child is running
 * at full tilt and making us run to keep up...
 */
g_usleep (0);
} else {
/* otherwise free up memory used to capture incoming data */
              bte::base::Chunk::prune();
}

      return FALSE(0);  /* If we need to go again, we already have a new timer for that. */
10500}

10502static gboolean
10503update_timeout (gpointer data) noexcept
10504try
10505{
GList *l, *next;

in_update_timeout = TRUE(!(0));

_bte_debug_print (BTE_DEBUG_WORK, "{")do { } while(0);
_bte_debug_print (BTE_DEBUG_TIMEOUT,do { } while(0)
                        "Update timeout:  %d active\n",do { } while(0)
                        g_list_length(g_active_terminals))do { } while(0);

      remove_process_timeout_source();

for (l = g_active_terminals; l != NULL__null; l = next) {
auto that = reinterpret_cast<bte::terminal::Terminal*>(l->data);

              next = l->next;

if (l != g_active_terminals) {
	_bte_debug_print (BTE_DEBUG_WORK, "T")do { } while(0);
}

              that->process(true);

              that->invalidate_dirty_rects_and_process_updates();
}

_bte_debug_print (BTE_DEBUG_WORK, "}")do { } while(0);

/* Set a timer such that we do not invalidate for a while. */
/* This limits the number of times we draw to ~40fps. */
update_timeout_tag =
g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE200,
		    BTE_UPDATE_REPEAT_TIMEOUT30,
		    update_repeat_timeout, NULL__null,
		    NULL__null);
in_update_timeout = FALSE(0);

return FALSE(0);
10543}
10544catch (...)
10545{
      bte::log_exception();
      return true; // false?
10548}

10550bool
10551Terminal::write_contents_sync (GOutputStream *stream,
                                       BteWriteFlags flags,
                                       GCancellable *cancellable,
                                       GError **error)
10555{
return _bte_ring_write_contents (m_screen->row_data,
			 stream, flags,
			 cancellable, error);
10559}

10561/*
* Buffer search
*/

10565/* TODO Add properties & signals */

10567/*
* Terminal::search_set_regex:
* @regex: (allow-none): a #BteRegex, or %nullptr
* @flags: PCRE2 match flags, or 0
*
* Sets the regex to search for. Unsets the search regex when passed %nullptr.
*/
10574bool
10575Terminal::search_set_regex (bte::base::RefPtr<bte::base::Regex>&& regex,
                          uint32_t flags)
10577{
      if (regex == m_search_regex &&
          flags == m_search_regex_match_flags)
              return false;

      m_search_regex = std::move(regex);
      m_search_regex_match_flags = flags;

invalidate_all();

      return true;
10588}

10590bool
10591Terminal::search_set_wrap_around(bool wrap)
10592{
      if (wrap == m_search_wrap_around)
              return false;

      m_search_wrap_around = wrap;
      return true;
10598}

10600bool
10601Terminal::search_rows(pcre2_match_context_8 *match_context,
                    pcre2_match_data_8 *match_data,
                    bte::grid::row_t start_row,
                    bte::grid::row_t end_row,
                    bool backward)
10606{
int start, end;
long start_col, end_col;
BteCharAttributes *ca;
GArray *attrs;
gdouble value, page_size;

auto row_text = get_text(start_row, 0,
                               end_row, 0,
                               false /* block */,
                               true /* wrap */,
                               nullptr);

      int (* match_fn) (const pcre2_code_8 *,
                        PCRE2_SPTR8, PCRE2_SIZEsize_t, PCRE2_SIZEsize_t, uint32_t,
                        pcre2_match_data_8 *, pcre2_match_context_8 *);
      gsize *ovector, so, eo;
      int r;

      if (m_search_regex->jited())
              match_fn = pcre2_jit_match_8;
      else
              match_fn = pcre2_match_8;

      r = match_fn(m_search_regex->code(),
                   (PCRE2_SPTR8)row_text->str, row_text->len , /* subject, length */
                   0, /* start offset */
                   m_search_regex_match_flags |
                   PCRE2_NO_UTF_CHECK0x40000000u | PCRE2_NOTEMPTY0x00000004u | PCRE2_PARTIAL_SOFT0x00000010u /* FIXME: HARD? */,
                   match_data,
                   match_context);

      if (r == PCRE2_ERROR_NOMATCH(-1)) {
              g_string_free (row_text, TRUE(!(0)));
              return false;
      }
      // FIXME: handle partial matches (PCRE2_ERROR_PARTIAL)
      if (r < 0) {
              g_string_free (row_text, TRUE(!(0)));
              return false;
      }

      ovector = pcre2_get_ovector_pointer_8(match_data);
      so = ovector[0];
      eo = ovector[1];
      if (G_UNLIKELY(so == PCRE2_UNSET || eo == PCRE2_UNSET)(__builtin_expect (__extension__ ({ int _g_boolean_var_1042; if
 (so == (~(size_t)0) || eo == (~(size_t)0)) _g_boolean_var_1042
 = 1; else _g_boolean_var_1042 = 0; _g_boolean_var_1042; }), 0
))) {
              g_string_free (row_text, TRUE(!(0)));
              return false;
      }

      start = so;
      end = eo;

/* Fetch text again, with attributes */
g_string_free(row_text, TRUE(!(0)));
if (!m_search_attrs)
m_search_attrs = g_array_new (FALSE(0), TRUE(!(0)), sizeof (BteCharAttributes));
attrs = m_search_attrs;
row_text = get_text(start_row, 0,
                          end_row, 0,
                          false /* block */,
                          true /* wrap */,
                          attrs);

ca = &g_array_index (attrs, BteCharAttributes, start)(((BteCharAttributes*) (void *) (attrs)->data) [(start)]);
start_row = ca->row;
start_col = ca->column;
ca = &g_array_index (attrs, BteCharAttributes, end - 1)(((BteCharAttributes*) (void *) (attrs)->data) [(end - 1)]
);
end_row = ca->row;
      end_col = ca->column + ca->columns;

g_string_free (row_text, TRUE(!(0)));

select_text(start_col, start_row, end_col, end_row);
/* Quite possibly the math here should not access adjustment directly... */
      value = ctk_adjustment_get_value(m_vadjustment.get());
      page_size = ctk_adjustment_get_page_size(m_vadjustment.get());
if (backward) {
if (end_row < value || end_row > value + page_size - 1)
	queue_adjustment_value_changed_clamped(end_row - page_size + 1);
} else {
if (start_row < value || start_row > value + page_size - 1)
	queue_adjustment_value_changed_clamped(start_row);
}

return true;
10692}

10694bool
10695Terminal::search_rows_iter(pcre2_match_context_8 *match_context,
                                   pcre2_match_data_8 *match_data,
                                   bte::grid::row_t start_row,
                                   bte::grid::row_t end_row,
                                   bool backward)
10700{
const BteRowData *row;
long iter_start_row, iter_end_row;

if (backward) {
iter_start_row = end_row;
while (iter_start_row > start_row) {
	iter_end_row = iter_start_row;

	do {
		iter_start_row--;
		row = find_row_data(iter_start_row);
	} while (row && row->attr.soft_wrapped);

	if (search_rows(match_context, match_data,
                                      iter_start_row, iter_end_row, backward))
		return true;
}
} else {
iter_end_row = start_row;
while (iter_end_row < end_row) {
	iter_start_row = iter_end_row;

	do {
		row = find_row_data(iter_end_row);
		iter_end_row++;
	} while (row && row->attr.soft_wrapped);

	if (search_rows(match_context, match_data,
                                      iter_start_row, iter_end_row, backward))
		return true;
}
}

return false;
10735}

10737bool
10738Terminal::search_find (bool backward)
10739{
      bte::grid::row_t buffer_start_row, buffer_end_row;
      bte::grid::row_t last_start_row, last_end_row;
      bool match_found = true;

      if (!m_search_regex)
              return false;

/* TODO
* Currently We only find one result per extended line, and ignore columns
* Moreover, the whole search thing is implemented very inefficiently.
*/

      auto match_context = create_match_context();
      auto match_data = pcre2_match_data_create_8(256 /* should be plenty */, nullptr /* general context */);

buffer_start_row = _bte_ring_delta (m_screen->row_data);
buffer_end_row = _bte_ring_next (m_screen->row_data);

      if (!m_selection_resolved.empty()) {
              last_start_row = m_selection_resolved.start_row();
              last_end_row = m_selection_resolved.end_row() + 1;
} else {
last_start_row = m_screen->scroll_delta + m_row_count;
last_end_row = m_screen->scroll_delta;
}
last_start_row = MAX (buffer_start_row, last_start_row)(((buffer_start_row) > (last_start_row)) ? (buffer_start_row
) : (last_start_row));
last_end_row = MIN (buffer_end_row, last_end_row)(((buffer_end_row) < (last_end_row)) ? (buffer_end_row) : (
last_end_row));

/* If search fails, we make an empty selection at the last searched
* position... */
if (backward) {
if (search_rows_iter (match_context, match_data,
                                    buffer_start_row, last_start_row, backward))
	goto found;
if (m_search_wrap_around &&
    search_rows_iter (match_context, match_data,
                                    last_end_row, buffer_end_row, backward))
	goto found;
              if (!m_selection_resolved.empty()) {
	if (m_search_wrap_around)
                          select_empty(m_selection_resolved.start_column(), m_selection_resolved.start_row());
	else
	    select_empty(-1, buffer_start_row - 1);
}
              match_found = false;
} else {
if (search_rows_iter (match_context, match_data,
                                    last_end_row, buffer_end_row, backward))
	goto found;
if (m_search_wrap_around &&
    search_rows_iter (match_context, match_data,
                                    buffer_start_row, last_start_row, backward))
	goto found;
              if (!m_selection_resolved.empty()) {
	if (m_search_wrap_around)
                              select_empty(m_selection_resolved.end_column(), m_selection_resolved.end_row());
	else
                              select_empty(0, buffer_end_row);
}
              match_found = false;
}

found:

      pcre2_match_data_free_8(match_data);
      pcre2_match_context_free_8(match_context);

return match_found;
10808}

10810/*
* Terminal::set_input_enabled:
* @enabled: whether to enable user input
*
* Enables or disables user input. When user input is disabled,
* the terminal's child will not receive any key press, or mouse button
* press or motion events sent to it.
*
* Returns: %true iff the setting changed
*/
10820bool
10821Terminal::set_input_enabled (bool enabled)
10822{
      if (enabled == m_input_enabled)
              return false;

      m_input_enabled = enabled;

      auto context = ctk_widget_get_style_context(m_widget);

      /* FIXME: maybe hide cursor when input disabled, too? */

      if (enabled) {
              if (m_has_focus)
                      widget()->im_focus_in();

              ctk_style_context_remove_class (context, CTK_STYLE_CLASS_READ_ONLY"read-only");
      } else {
              im_reset();
              if (m_has_focus)
                      widget()->im_focus_out();

              disconnect_pty_write();
              _bte_byte_array_clear(m_outgoing)g_byte_array_set_size (m_outgoing, 0);

              ctk_style_context_add_class (context, CTK_STYLE_CLASS_READ_ONLY"read-only");
      }

      return true;
10849}

10851std::optional<std::vector<char32_t>>
10852Terminal::process_word_char_exceptions(std::string_view str_view) const noexcept
10853{
      auto str = str_view.data();

      auto array = std::vector<char32_t>{};
      array.reserve(g_utf8_strlen(str, -1));

      for (auto const* p = str; *p; p = g_utf8_next_char(p)(char *)((p) + g_utf8_skip[*(const guchar *)(p)])) {
              auto const c = g_utf8_get_char(p);

              /* For forward compatibility reasons, we skip
               * characters that aren't supposed to be here,
               * instead of erroring out.
               */
              /* '-' must only be used*  at the start of the string */
              if (c == (gunichar)'-' && p != str)
                      continue;
              if (!g_unichar_isgraph(c))
                      continue;
              if (g_unichar_isspace(c))
                      continue;
              if (g_unichar_isalnum(c))
                      continue;

              array.push_back(c);
      }

      /* Sort the result since we want to use bsearch on it */
      std::sort(std::begin(array), std::end(array));

      /* Check that no character occurs twice */
      for (size_t i = 1; i < array.size(); ++i) {
              if (array[i-1] != array[i])
                      continue;

              return std::nullopt;
      }

10890#if 0
      /* Debug */
      for (auto const c : array) {
              char utf[7];
              utf[g_unichar_to_utf8(c, utf)] = '\0';
              g_printerr("Word char exception: U+%04X %s\n", c, utf);
      }
10897#endif

      return array;
10900}

10902/*
* Terminal::set_word_char_exceptions:
* @exceptions: a string of ASCII punctuation characters, or %nullptr
*
* With this function you can provide a set of characters which will
* be considered parts of a word when doing word-wise selection, in
* addition to the default which only considers alphanumeric characters
* part of a word.
*
* The characters in @exceptions must be non-alphanumeric, each character
* must occur only once, and if @exceptions contains the character
* U+002D HYPHEN-MINUS, it must be at the start of the string.
*
* Use %nullptr to reset the set of exception characters to the default.
*
* Returns: %true if the word char exceptions changed
*/
10919bool
10920Terminal::set_word_char_exceptions(std::optional<std::string_view> stropt)
10921{
      if (auto array = process_word_char_exceptions(stropt ? stropt.value() : WORD_CHAR_EXCEPTIONS_DEFAULT"-#%&+,./=?@\\_~\302\267"sv)) {
              m_word_char_exceptions = *array;
              return true;
      }

      return false;
10928}

10930void
10931Terminal::set_clear_background(bool setting)
10932{
      if (m_clear_background == setting)
              return;

      m_clear_background = setting;
      invalidate_all();
10938}

10940} // namespace terminal
10941} // namespace bte